launchdarkly-server-sdk 8.11.3 → 8.12.0

data/lib/ldclient-rb/impl/data_system/fdv2.rb

@@ -14,6 +14,30 @@ require "ldclient-rb/interfaces/data_system"
 module LaunchDarkly
   module Impl
     module DataSystem
+      #
+      # Represents the possible outcomes from consuming synchronizer results.
+      #
+      # Used by {FDv2#consume_synchronizer_results} to indicate what action the
+      # synchronizer loop should take next.
+      #
+      module SyncResult
+        # Temporarily move to the next synchronizer in the list.
+        # The current synchronizer remains available for future recovery.
+        FALLBACK = :fallback
+
+        # Return to the first synchronizer in the list.
+        # Used when recovery conditions are met on a fallback synchronizer.
+        RECOVER = :recover
+
+        # Permanently remove the current synchronizer from the list.
+        # Used for unrecoverable failures (OFF state, exceptions).
+        REMOVE = :remove
+
+        # Switch to the FDv1 protocol fallback.
+        # Replaces the synchronizer list with the FDv1 fallback synchronizer.
+        FDV1 = :fdv1
+      end
+
       # FDv2 is an implementation of the DataSystem interface that uses the Flag Delivery V2 protocol
       # for obtaining and keeping data up-to-date. Additionally, it operates with an optional persistent
       # store in read-only or read/write mode.
@@ -30,8 +54,7 @@ module LaunchDarkly
           @config = config
           @data_system_config = data_system_config
           @logger = config.logger
-          @primary_synchronizer_builder = data_system_config.primary_synchronizer
-          @secondary_synchronizer_builder = data_system_config.secondary_synchronizer
+          @synchronizer_builders = data_system_config.synchronizers || []
           @fdv1_fallback_synchronizer_builder = data_system_config.fdv1_fallback_synchronizer
           @disabled = @config.offline?
 
@@ -86,7 +109,7 @@ module LaunchDarkly
 
           # Track configuration
           @configured_with_data_sources = (@data_system_config.initializers && !@data_system_config.initializers.empty?) ||
-            !@data_system_config.primary_synchronizer.nil?
+            !@synchronizer_builders.empty?
         end
 
         # (see DataSystem#start)
@@ -214,7 +237,7 @@ module LaunchDarkly
             return if @stop_event.set?
 
             begin
-              initializer = initializer_builder.call(@sdk_key, @config)
+              initializer = initializer_builder.build(@sdk_key, @config)
               @logger.info { "[LDClient] Attempting to initialize via #{initializer.name}" }
 
               basis_result = initializer.fetch(@store)
@@ -246,8 +269,8 @@ module LaunchDarkly
         # @return [void]
         #
         def run_synchronizers
-          # If no primary synchronizer configured, just set ready and return
-          if @primary_synchronizer_builder.nil?
+          # If no synchronizers configured, just set ready and return
+          if @synchronizer_builders.empty?
             @ready_event.set
             return
           end
@@ -259,79 +282,64 @@ module LaunchDarkly
         end
 
         #
-        # Synchronizer loop that manages primary/secondary/fallback synchronizers.
+        # Synchronizer loop that manages synchronizers and fallbacks.
         #
         # @return [void]
         #
         def synchronizer_loop
+          # Track the current index in the synchronizer array
+          current_index = 0
+
           begin
-            while !@stop_event.set? && @primary_synchronizer_builder
-              # Try primary synchronizer
+            while !@stop_event.set? && current_index < @synchronizer_builders.length
+              synchronizer_builder = @synchronizer_builders[current_index]
+              is_primary = current_index == 0
+
               begin
                 @lock.synchronize do
-                  primary_sync = @primary_synchronizer_builder.call(@sdk_key, @config)
-                  if primary_sync.respond_to?(:set_diagnostic_accumulator) && @diagnostic_accumulator
-                    primary_sync.set_diagnostic_accumulator(@diagnostic_accumulator)
+                  sync = synchronizer_builder.build(@sdk_key, @config)
+                  if sync.respond_to?(:set_diagnostic_accumulator) && @diagnostic_accumulator
+                    sync.set_diagnostic_accumulator(@diagnostic_accumulator)
                   end
-                  @active_synchronizer = primary_sync
+                  @active_synchronizer = sync
                 end
 
-                @logger.info { "[LDClient] Primary synchronizer #{@active_synchronizer.name} is starting" }
+                @logger.info { "[LDClient] Synchronizer[#{current_index}] #{@active_synchronizer.name} is starting" }
 
-                remove_sync, fallback_v1 = consume_synchronizer_results(
-                  @active_synchronizer,
-                  method(:fallback_condition)
-                )
+                sync_result = consume_synchronizer_results(@active_synchronizer, check_recovery: !is_primary)
 
-                if remove_sync
-                  @primary_synchronizer_builder = fallback_v1 ? @fdv1_fallback_synchronizer_builder : @secondary_synchronizer_builder
-                  @secondary_synchronizer_builder = nil
+                break if @stop_event.set?
 
-                  if @primary_synchronizer_builder.nil?
-                    @logger.warn { "[LDClient] No more synchronizers available" }
-                    @data_source_status_provider.update_status(
-                      LaunchDarkly::Interfaces::DataSource::Status::OFF,
-                      @data_source_status_provider.status.last_error
-                    )
-                    break
+                case sync_result
+                when SyncResult::FDV1
+                  if @fdv1_fallback_synchronizer_builder
+                    @synchronizer_builders = [@fdv1_fallback_synchronizer_builder]
+                    current_index = 0
+                    next
                   end
+                  # No FDv1 fallback configured, treat as regular fallback
+                  current_index += 1
+                when SyncResult::RECOVER
+                  @logger.info { "[LDClient] Recovery condition met, returning to primary synchronizer" }
+                  current_index = 0
+                when SyncResult::REMOVE
+                  @logger.info { "[LDClient] Removing synchronizer from list due to permanent failure" }
+                  @synchronizer_builders.delete_at(current_index)
                 else
                   @logger.info { "[LDClient] Fallback condition met" }
+                  current_index += 1
                 end
 
-                break if @stop_event.set?
-
-                next if @secondary_synchronizer_builder.nil?
-
-                @lock.synchronize do
-                  secondary_sync = @secondary_synchronizer_builder.call(@sdk_key, @config)
-                  if secondary_sync.respond_to?(:set_diagnostic_accumulator) && @diagnostic_accumulator
-                    secondary_sync.set_diagnostic_accumulator(@diagnostic_accumulator)
-                  end
-                  @logger.info { "[LDClient] Secondary synchronizer #{secondary_sync.name} is starting" }
-                  @active_synchronizer = secondary_sync
-                end
+                current_index = 0 if current_index >= @synchronizer_builders.length
 
-                remove_sync, fallback_v1 = consume_synchronizer_results(
-                  @active_synchronizer,
-                  method(:recovery_condition)
-                )
-
-                if remove_sync
-                  @secondary_synchronizer_builder = nil
-                  @primary_synchronizer_builder = @fdv1_fallback_synchronizer_builder if fallback_v1
-
-                  if @primary_synchronizer_builder.nil?
-                    @logger.warn { "[LDClient] No more synchronizers available" }
-                    @data_source_status_provider.update_status(
-                      LaunchDarkly::Interfaces::DataSource::Status::OFF,
-                      @data_source_status_provider.status.last_error
-                    )
-                    break
-                  end
+                if @synchronizer_builders.length == 0
+                  @logger.warn { "[LDClient] No more synchronizers available" }
+                  @data_source_status_provider.update_status(
+                    LaunchDarkly::Interfaces::DataSource::Status::OFF,
+                    @data_source_status_provider.status.last_error
+                  )
+                  break
                 end
-
-                @logger.info { "[LDClient] Recovery condition met, returning to primary synchronizer" }
               rescue => e
                 @logger.error { "[LDClient] Failed to build synchronizer: #{e.message}" }
                 break
@@ -353,10 +361,10 @@ module LaunchDarkly
         # Consume results from a synchronizer until a condition is met or it fails.
         #
         # @param synchronizer [Object] The synchronizer
-        # @param condition_func [Proc] Function to check if condition is met
-        # @return [Array(Boolean, Boolean)] [should_remove_sync, fallback_to_fdv1]
+        # @param check_recovery [Boolean] Whether to check recovery condition (healthy too long)
+        # @return [Symbol] One of {SyncResult::FALLBACK}, {SyncResult::RECOVER}, {SyncResult::REMOVE}, or {SyncResult::FDV1}
         #
-        def consume_synchronizer_results(synchronizer, condition_func)
+        def consume_synchronizer_results(synchronizer, check_recovery: false)
           action_queue = Queue.new
           timer = LaunchDarkly::Impl::RepeatingTask.new(10, 10, -> { action_queue.push("check") }, @logger, "FDv2-sync-cond-timer")
 
@@ -384,13 +392,14 @@ module LaunchDarkly
                 if update == "check"
                   # Check condition periodically
                   current_status = @data_source_status_provider.status
-                  return [false, false] if condition_func.call(current_status)
+                  return SyncResult::RECOVER if check_recovery && recovery_condition(current_status)
+                  return SyncResult::FALLBACK if fallback_condition(current_status)
                 end
                 next
               end
 
               @logger.info { "[LDClient] Synchronizer #{synchronizer.name} update: #{update.state}" }
-              return [false, false] if @stop_event.set?
+              return SyncResult::FALLBACK if @stop_event.set?
 
               # Handle the update
               @store.apply(update.change_set, true) if update.change_set
@@ -401,26 +410,24 @@ module LaunchDarkly
               # Update status
               @data_source_status_provider.update_status(update.state, update.error)
 
-              # Check if we should revert to FDv1 immediately
-              return [true, true] if update.revert_to_fdv1
+              return SyncResult::FDV1 if update.revert_to_fdv1
 
-              # Check for OFF state indicating permanent failure
-              return [true, false] if update.state == LaunchDarkly::Interfaces::DataSource::Status::OFF
+              return SyncResult::REMOVE if update.state == LaunchDarkly::Interfaces::DataSource::Status::OFF
             end
           rescue => e
             @logger.error { "[LDClient] Error consuming synchronizer results: #{e.message}" }
-            return [true, false]
+            return SyncResult::REMOVE
           ensure
             synchronizer.stop
             timer.stop
             sync_reader.join(0.5) if sync_reader.alive?
           end
 
-          [true, false]
+          SyncResult::REMOVE
         end
 
         #
-        # Determine if we should fallback to secondary synchronizer.
+        # Determine if we should fallback to the next synchronizer.
         #
         # @param status [LaunchDarkly::Interfaces::DataSource::Status] Current data source status
         # @return [Boolean] true if fallback condition is met
@@ -435,20 +442,14 @@ module LaunchDarkly
         end
 
         #
-        # Determine if we should try to recover to primary synchronizer.
+        # Determine if we should recover to the primary synchronizer.
         #
         # @param status [LaunchDarkly::Interfaces::DataSource::Status] Current data source status
-        # @return [Boolean] true if recovery condition is met
+        # @return [Boolean] true if recovery condition is met (healthy for too long)
         #
         def recovery_condition(status)
-          interrupted_at_runtime = status.state == LaunchDarkly::Interfaces::DataSource::Status::INTERRUPTED &&
-            Time.now - status.state_since > 60  # 1 minute
-          healthy_for_too_long = status.state == LaunchDarkly::Interfaces::DataSource::Status::VALID &&
+          status.state == LaunchDarkly::Interfaces::DataSource::Status::VALID &&
             Time.now - status.state_since > 300  # 5 minutes
-          cannot_initialize = status.state == LaunchDarkly::Interfaces::DataSource::Status::INITIALIZING &&
-            Time.now - status.state_since > 10  # 10 seconds
-
-          interrupted_at_runtime || healthy_for_too_long || cannot_initialize
         end
 
         #

data/lib/ldclient-rb/impl/data_system/http_config_options.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+module LaunchDarkly
+  module Impl
+    module DataSystem
+      #
+      # HttpConfigOptions contains HTTP connection configuration settings.
+      # This class is created by data source builders and passed to v2 Requesters/DataSources.
+      #
+      class HttpConfigOptions
+        # Generic HTTP defaults - base URIs live in the respective builders
+        DEFAULT_READ_TIMEOUT = 10
+        DEFAULT_CONNECT_TIMEOUT = 2
+
+        attr_reader :base_uri, :socket_factory, :read_timeout, :connect_timeout
+
+        #
+        # @param base_uri [String] The base URI for HTTP requests
+        # @param socket_factory [Object, nil] Optional socket factory for custom connections
+        # @param read_timeout [Float, nil] Read timeout in seconds (defaults to DEFAULT_READ_TIMEOUT)
+        # @param connect_timeout [Float, nil] Connect timeout in seconds (defaults to DEFAULT_CONNECT_TIMEOUT)
+        #
+        def initialize(base_uri:, socket_factory: nil, read_timeout: nil, connect_timeout: nil)
+          @base_uri = base_uri
+          @socket_factory = socket_factory
+          @read_timeout = read_timeout || DEFAULT_READ_TIMEOUT
+          @connect_timeout = connect_timeout || DEFAULT_CONNECT_TIMEOUT
+        end
+      end
+    end
+  end
+end

data/lib/ldclient-rb/impl/data_system/polling.rb

@@ -4,6 +4,7 @@ require "ldclient-rb/interfaces"
 require "ldclient-rb/interfaces/data_system"
 require "ldclient-rb/impl/data_system"
 require "ldclient-rb/impl/data_system/protocolv2"
+require "ldclient-rb/impl/data_system/data_source_builder_common"
 require "ldclient-rb/impl/data_source/requestor"
 require "ldclient-rb/impl/util"
 require "concurrent"
@@ -17,8 +18,8 @@ module LaunchDarkly
       FDV2_POLLING_ENDPOINT = "/sdk/poll"
       FDV1_POLLING_ENDPOINT = "/sdk/latest-all"
 
-      LD_ENVID_HEADER = "x-launchdarkly-env-id"
-      LD_FD_FALLBACK_HEADER = "x-launchdarkly-fd-fallback"
+      LD_ENVID_HEADER = "X-LD-EnvID"
+      LD_FD_FALLBACK_HEADER = "X-LD-FD-Fallback"
 
       #
       # Requester protocol for polling data source
@@ -93,8 +94,6 @@ module LaunchDarkly
         #
         def sync(ss)
           @logger.info { "[LDClient] Starting PollingDataSourceV2 synchronizer" }
-          @stop.reset
-          @interrupt_event.reset
 
           until @stop.set?
             result = @requester.fetch(ss.selector)
@@ -251,14 +250,15 @@ module LaunchDarkly
 
         #
         # @param sdk_key [String]
-        # @param config [LaunchDarkly::Config]
+        # @param http_config [HttpConfigOptions] HTTP connection settings
+        # @param config [LaunchDarkly::Config] Used for global header settings
         #
-        def initialize(sdk_key, config)
+        def initialize(sdk_key, http_config, config)
           @etag = nil
           @config = config
           @sdk_key = sdk_key
-          @poll_uri = config.base_uri + FDV2_POLLING_ENDPOINT
-          @http_client = Impl::Util.new_http_client(config.base_uri, config)
+          @poll_uri = http_config.base_uri + FDV2_POLLING_ENDPOINT
+          @http_client = Impl::Util.new_http_client(http_config)
             .use(:auto_inflate)
             .headers("Accept-Encoding" => "gzip")
         end
@@ -342,14 +342,15 @@ module LaunchDarkly
 
         #
         # @param sdk_key [String]
-        # @param config [LaunchDarkly::Config]
+        # @param http_config [HttpConfigOptions] HTTP connection settings
+        # @param config [LaunchDarkly::Config] Used for global header settings and payload_filter_key
         #
-        def initialize(sdk_key, config)
+        def initialize(sdk_key, http_config, config)
           @etag = nil
           @config = config
           @sdk_key = sdk_key
-          @poll_uri = config.base_uri + FDV1_POLLING_ENDPOINT
-          @http_client = Impl::Util.new_http_client(config.base_uri, config)
+          @poll_uri = http_config.base_uri + FDV1_POLLING_ENDPOINT
+          @http_client = Impl::Util.new_http_client(http_config)
             .use(:auto_inflate)
             .headers("Accept-Encoding" => "gzip")
         end
@@ -440,7 +441,7 @@ module LaunchDarkly
 
           next unless event[:event]
 
-          case event[:event]
+          case event[:event].to_sym
           when LaunchDarkly::Interfaces::DataSystem::EventName::SERVER_INTENT
             begin
               server_intent = LaunchDarkly::Interfaces::DataSystem::ServerIntent.from_h(event[:data])
@@ -518,7 +519,7 @@ module LaunchDarkly
             version = flag_or_segment[:version]
             return LaunchDarkly::Result.fail("Invalid format: #{key} does not have a version set") if version.nil?
 
-            builder.add_put(kind, key.to_s, version, flag_or_segment)
+            builder.add_put(kind, key, version, flag_or_segment)
           end
         end
 
@@ -529,14 +530,24 @@ module LaunchDarkly
       # Builder for a PollingDataSource.
       #
       class PollingDataSourceBuilder
+        include DataSourceBuilderCommon
+
+        DEFAULT_BASE_URI = "https://sdk.launchdarkly.com"
+        DEFAULT_POLL_INTERVAL = 30
+
+        def initialize
+          @requester = nil
+        end
+
         #
-        # @param sdk_key [String]
-        # @param config [LaunchDarkly::Config]
+        # Sets the polling interval in seconds.
         #
-        def initialize(sdk_key, config)
-          @sdk_key = sdk_key
-          @config = config
-          @requester = nil
+        # @param secs [Float] Polling interval in seconds
+        # @return [PollingDataSourceBuilder]
+        #
+        def poll_interval(secs)
+          @poll_interval = secs
+          self
         end
 
         #
@@ -553,11 +564,14 @@ module LaunchDarkly
         #
         # Builds the PollingDataSource with the configured parameters.
         #
+        # @param sdk_key [String]
+        # @param config [LaunchDarkly::Config]
         # @return [PollingDataSource]
         #
-        def build
-          requester = @requester || HTTPPollingRequester.new(@sdk_key, @config)
-          PollingDataSource.new(@config.poll_interval, requester, @config.logger)
+        def build(sdk_key, config)
+          http_opts = build_http_config
+          requester = @requester || HTTPPollingRequester.new(sdk_key, http_opts, config)
+          PollingDataSource.new(@poll_interval || DEFAULT_POLL_INTERVAL, requester, config.logger)
         end
       end
 
@@ -565,14 +579,24 @@ module LaunchDarkly
       # Builder for an FDv1 PollingDataSource.
       #
       class FDv1PollingDataSourceBuilder
+        include DataSourceBuilderCommon
+
+        DEFAULT_BASE_URI = "https://sdk.launchdarkly.com"
+        DEFAULT_POLL_INTERVAL = 30
+
+        def initialize
+          @requester = nil
+        end
+
         #
-        # @param sdk_key [String]
-        # @param config [LaunchDarkly::Config]
+        # Sets the polling interval in seconds.
         #
-        def initialize(sdk_key, config)
-          @sdk_key = sdk_key
-          @config = config
-          @requester = nil
+        # @param secs [Float] Polling interval in seconds
+        # @return [FDv1PollingDataSourceBuilder]
+        #
+        def poll_interval(secs)
+          @poll_interval = secs
+          self
         end
 
         #
@@ -589,11 +613,14 @@ module LaunchDarkly
         #
         # Builds the PollingDataSource with the configured parameters.
         #
+        # @param sdk_key [String]
+        # @param config [LaunchDarkly::Config]
         # @return [PollingDataSource]
         #
-        def build
-          requester = @requester || HTTPFDv1PollingRequester.new(@sdk_key, @config)
-          PollingDataSource.new(@config.poll_interval, requester, @config.logger)
+        def build(sdk_key, config)
+          http_opts = build_http_config
+          requester = @requester || HTTPFDv1PollingRequester.new(sdk_key, http_opts, config)
+          PollingDataSource.new(@poll_interval || DEFAULT_POLL_INTERVAL, requester, config.logger)
         end
       end
     end

data/lib/ldclient-rb/impl/data_system/protocolv2.rb

@@ -22,13 +22,13 @@ module LaunchDarkly
           # @return [String] The object kind ({LaunchDarkly::Interfaces::DataSystem::ObjectKind})
           attr_reader :kind
 
-          # @return [String] The key
+          # @return [Symbol] The key
           attr_reader :key
 
           #
           # @param version [Integer] The version
           # @param kind [String] The object kind ({LaunchDarkly::Interfaces::DataSystem::ObjectKind})
-          # @param key [String] The key
+          # @param key [Symbol] The key
           #
           def initialize(version:, kind:, key:)
             @version = version
@@ -39,7 +39,7 @@ module LaunchDarkly
           #
           # Returns the event name.
           #
-          # @return [String]
+          # @return [Symbol]
           #
           def name
             LaunchDarkly::Interfaces::DataSystem::EventName::DELETE_OBJECT
@@ -72,7 +72,7 @@ module LaunchDarkly
 
             raise ArgumentError, "Missing required fields in DeleteObject" if version.nil? || kind.nil? || key.nil?
 
-            new(version: version, kind: kind, key: key)
+            new(version: version, kind: kind, key: key.to_sym)
           end
         end
 
@@ -89,7 +89,7 @@ module LaunchDarkly
           # @return [String] The object kind ({LaunchDarkly::Interfaces::DataSystem::ObjectKind})
           attr_reader :kind
 
-          # @return [String] The key
+          # @return [Symbol] The key
           attr_reader :key
 
           # @return [Hash] The object data
@@ -98,7 +98,7 @@ module LaunchDarkly
           #
           # @param version [Integer] The version
           # @param kind [String] The object kind ({LaunchDarkly::Interfaces::DataSystem::ObjectKind})
-          # @param key [String] The key
+          # @param key [Symbol] The key
           # @param object [Hash] The object data
           #
           def initialize(version:, kind:, key:, object:)
@@ -111,7 +111,7 @@ module LaunchDarkly
           #
           # Returns the event name.
           #
-          # @return [String]
+          # @return [Symbol]
           #
           def name
             LaunchDarkly::Interfaces::DataSystem::EventName::PUT_OBJECT
@@ -146,7 +146,7 @@ module LaunchDarkly
 
             raise ArgumentError, "Missing required fields in PutObject" if version.nil? || kind.nil? || key.nil? || object_data.nil?
 
-            new(version: version, kind: kind, key: key, object: object_data)
+            new(version: version, kind: kind, key: key.to_sym, object: object_data)
           end
         end