launchdarkly-server-sdk 8.11.1 → 8.11.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: e13dd73f598b3c784c48f2f1d935bff9ac8211717dbaa224b9cf856d909ea054
-  data.tar.gz: 53e5f7b84ff83e6770aa8f49e7b972c452fde3625168f95efa1569b9310b4266
+  metadata.gz: e0821343a2375748e37f95a7a43016973a21c6027d9f0b3c402074ae9859c91b
+  data.tar.gz: d285b359f653ed6ea74d9b6fedd8ff0388347e24d986f72866c226b24516ed38
 SHA512:
-  metadata.gz: d6c290d83db944daebe948c1d799668010c1e879d4986e377298a28abc87e046f9c23051c830a80ac7422f6cfb62ed9025c4f224e693f0be36dbc63073ed15c6
-  data.tar.gz: 26ba1dd07b32763589eeaf7c9f55b53105dce4b7da2fc73430927646f27c1e2756d3feaa2608aa7adec7481876ec6661c6af0ceee2b58ac32ece35765306723a
+  metadata.gz: e9937a4267ca69970169b66564e1fdfff11e7ceefa57462a0f4f11830aa6ef8cefc34dbcb83e62910759c14ba3120d53c20ba7436d87f21aff0a63ad2996ff8f
+  data.tar.gz: 6726a6c125e3253c691d8c566e46ef17dc29cfb76407e79232f9b213580bfc53665bf1968fc60b48641a93276b8b4bd6c2bdabce77bda70f4575df2e5b61ec11

data/lib/ldclient-rb/events.rb

@@ -231,7 +231,7 @@ module LaunchDarkly
     def initialize(inbox, sdk_key, config, diagnostic_accumulator, event_sender)
       @sdk_key = sdk_key
       @config = config
-      @diagnostic_accumulator = config.diagnostic_opt_out? ? nil : diagnostic_accumulator
+      @diagnostic_accumulator = diagnostic_accumulator
       @event_sender = event_sender
       @sampler = LaunchDarkly::Impl::Sampler.new(Random.new)
 

data/lib/ldclient-rb/impl/data_source/null_processor.rb

@@ -0,0 +1,52 @@
+require 'concurrent'
+require 'ldclient-rb/interfaces'
+
+module LaunchDarkly
+  module Impl
+    module DataSource
+      #
+      # A minimal UpdateProcessor implementation used when the SDK is in offline mode
+      # or daemon (LDD) mode. It does nothing except mark itself as initialized.
+      #
+      class NullUpdateProcessor
+        include LaunchDarkly::Interfaces::DataSource
+
+        #
+        # Creates a new NullUpdateProcessor.
+        #
+        def initialize
+          @ready = Concurrent::Event.new
+        end
+
+        #
+        # Starts the data source. Since this is a null implementation, it immediately
+        # sets the ready event to indicate initialization is complete.
+        #
+        # @return [Concurrent::Event] The ready event
+        #
+        def start
+          @ready.set
+          @ready
+        end
+
+        #
+        # Stops the data source. This is a no-op for the null implementation.
+        #
+        # @return [void]
+        #
+        def stop
+          # Nothing to do
+        end
+
+        #
+        # Checks if the data source has been initialized.
+        #
+        # @return [Boolean] Always returns true since this is a null implementation
+        #
+        def initialized?
+          true
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,165 @@
+require 'concurrent'
+require 'ldclient-rb/impl/broadcaster'
+require 'ldclient-rb/impl/data_source'
+require 'ldclient-rb/impl/data_source/null_processor'
+require 'ldclient-rb/impl/data_store'
+require 'ldclient-rb/impl/data_system'
+require 'ldclient-rb/impl/store_client_wrapper'
+
+module LaunchDarkly
+  module Impl
+    module DataSystem
+      #
+      # FDv1 wires the existing v1 data source and store behavior behind the
+      # generic DataSystem surface.
+      #
+      # @see DataSystem
+      #
+      class FDv1
+        include LaunchDarkly::Impl::DataSystem
+
+        #
+        # Creates a new FDv1 data system.
+        #
+        # @param sdk_key [String] The SDK key
+        # @param config [LaunchDarkly::Config] The SDK configuration
+        #
+        def initialize(sdk_key, config)
+          @sdk_key = sdk_key
+          @config = config
+          @shared_executor = Concurrent::SingleThreadExecutor.new
+
+          # Set up data store plumbing
+          @data_store_broadcaster = LaunchDarkly::Impl::Broadcaster.new(@shared_executor, @config.logger)
+          @data_store_update_sink = LaunchDarkly::Impl::DataStore::UpdateSink.new(
+            @data_store_broadcaster
+          )
+
+          # Wrap the data store with client wrapper (must be created before status provider)
+          @store_wrapper = LaunchDarkly::Impl::FeatureStoreClientWrapper.new(
+            @config.feature_store,
+            @data_store_update_sink,
+            @config.logger
+          )
+
+          # Create status provider with store wrapper
+          @data_store_status_provider = LaunchDarkly::Impl::DataStore::StatusProvider.new(
+            @store_wrapper,
+            @data_store_update_sink
+          )
+
+          # Set up data source plumbing
+          @data_source_broadcaster = LaunchDarkly::Impl::Broadcaster.new(@shared_executor, @config.logger)
+          @flag_change_broadcaster = LaunchDarkly::Impl::Broadcaster.new(@shared_executor, @config.logger)
+          @data_source_update_sink = LaunchDarkly::Impl::DataSource::UpdateSink.new(
+            @store_wrapper,
+            @data_source_broadcaster,
+            @flag_change_broadcaster
+          )
+          @data_source_status_provider = LaunchDarkly::Impl::DataSource::StatusProvider.new(
+            @data_source_broadcaster,
+            @data_source_update_sink
+          )
+
+          # Ensure v1 processors can find the sink via config for status updates
+          @config.data_source_update_sink = @data_source_update_sink
+
+          # Update processor created in start()
+          @update_processor = nil
+
+          # Diagnostic accumulator provided by client for streaming metrics
+          @diagnostic_accumulator = nil
+        end
+
+        # (see DataSystem#start)
+        def start
+          @update_processor ||= make_update_processor
+          @update_processor.start
+        end
+
+        # (see DataSystem#stop)
+        def stop
+          @update_processor&.stop
+          @shared_executor.shutdown
+        end
+
+        # (see DataSystem#store)
+        def store
+          @store_wrapper
+        end
+
+        # (see DataSystem#set_diagnostic_accumulator)
+        def set_diagnostic_accumulator(diagnostic_accumulator)
+          @diagnostic_accumulator = diagnostic_accumulator
+        end
+
+        # (see DataSystem#data_source_status_provider)
+        def data_source_status_provider
+          @data_source_status_provider
+        end
+
+        # (see DataSystem#data_store_status_provider)
+        def data_store_status_provider
+          @data_store_status_provider
+        end
+
+        # (see DataSystem#flag_change_broadcaster)
+        def flag_change_broadcaster
+          @flag_change_broadcaster
+        end
+
+        #
+        # (see DataSystem#data_availability)
+        #
+        # In LDD mode, always returns CACHED for backwards compatibility,
+        # even if the store is empty.
+        #
+        def data_availability
+          return DataAvailability::DEFAULTS if @config.offline?
+          return DataAvailability::REFRESHED if @update_processor && @update_processor.initialized?
+          return DataAvailability::CACHED if @store_wrapper.initialized?
+
+          DataAvailability::DEFAULTS
+        end
+
+        # (see DataSystem#target_availability)
+        def target_availability
+          return DataAvailability::DEFAULTS if @config.offline?
+
+          DataAvailability::REFRESHED
+        end
+
+        #
+        # Creates the appropriate update processor based on the configuration.
+        #
+        # @return [Object] The update processor
+        #
+        private def make_update_processor
+          # Handle custom data source (factory or instance)
+          if @config.data_source
+            return @config.data_source unless @config.data_source.respond_to?(:call)
+
+            # Factory - call with appropriate arity
+            return @config.data_source.arity == 3 ?
+              @config.data_source.call(@sdk_key, @config, @diagnostic_accumulator) :
+              @config.data_source.call(@sdk_key, @config)
+          end
+
+          # Create default data source based on config
+          return LaunchDarkly::Impl::DataSource::NullUpdateProcessor.new if @config.offline? || @config.use_ldd?
+
+          if @config.stream?
+            require 'ldclient-rb/stream'
+            return LaunchDarkly::StreamProcessor.new(@sdk_key, @config, @diagnostic_accumulator)
+          end
+
+          # Polling processor
+          require 'ldclient-rb/polling'
+          requestor = LaunchDarkly::Requestor.new(@sdk_key, @config)
+          LaunchDarkly::PollingProcessor.new(@config, requestor)
+        end
+      end
+    end
+  end
+end
+

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

@@ -0,0 +1,298 @@
+module LaunchDarkly
+  module Impl
+    #
+    # Mixin that defines the required methods of a data system implementation. The data system
+    # is responsible for managing the SDK's data model, including storage, retrieval, and change
+    # detection for feature flag configurations.
+    #
+    # This module also contains supporting classes and additional mixins for data system
+    # implementations, such as DataAvailability, Update, and protocol-specific mixins.
+    #
+    # For operations that can fail, use {LaunchDarkly::Result} from util.rb.
+    #
+    # Application code should not need to implement this directly; it is used internally by the
+    # SDK's data system implementations.
+    #
+    # @private
+    #
+    module DataSystem
+      #
+      # Starts the data system.
+      #
+      # This method will return immediately. The returned event will be set when the system
+      # has reached an initial state (either permanently failed, e.g. due to bad auth, or succeeded).
+      #
+      # If called multiple times, returns the same event as the first call.
+      #
+      # @return [Concurrent::Event] Event that will be set when initialization is complete
+      #
+      def start
+        raise NotImplementedError, "#{self.class} must implement #start"
+      end
+
+      #
+      # Halts the data system. Should be called when the client is closed to stop any long running
+      # operations. Makes the data system no longer usable.
+      #
+      # @return [void]
+      #
+      def stop
+        raise NotImplementedError, "#{self.class} must implement #stop"
+      end
+
+      #
+      # Returns an interface for tracking the status of the data source.
+      #
+      # The data source is the mechanism that the SDK uses to get feature flag configurations, such
+      # as a streaming connection (the default) or poll requests.
+      #
+      # @return [LaunchDarkly::Interfaces::DataSource::StatusProvider]
+      #
+      def data_source_status_provider
+        raise NotImplementedError, "#{self.class} must implement #data_source_status_provider"
+      end
+
+      #
+      # Returns an interface for tracking the status of a persistent data store.
+      #
+      # The provider has methods for checking whether the data store is (as far
+      # as the SDK knows) currently operational, tracking changes in this
+      # status, and getting cache statistics. These are only relevant for a
+      # persistent data store; if you are using an in-memory data store, then
+      # this method will return a stub object that provides no information.
+      #
+      # @return [LaunchDarkly::Interfaces::DataStore::StatusProvider]
+      #
+      def data_store_status_provider
+        raise NotImplementedError, "#{self.class} must implement #data_store_status_provider"
+      end
+
+      #
+      # Returns the broadcaster for flag change notifications.
+      #
+      # Consumers can use this broadcaster to build their own flag tracker
+      # or listen for flag changes directly.
+      #
+      # @return [LaunchDarkly::Impl::Broadcaster]
+      #
+      def flag_change_broadcaster
+        raise NotImplementedError, "#{self.class} must implement #flag_change_broadcaster"
+      end
+
+      #
+      # Indicates what form of data is currently available.
+      #
+      # This is calculated dynamically based on current system state.
+      #
+      # @return [Symbol] one of the {DataAvailability} constants
+      #
+      def data_availability
+        raise NotImplementedError, "#{self.class} must implement #data_availability"
+      end
+
+      #
+      # Indicates the ideal form of data attainable given the current configuration.
+      #
+      # @return [Symbol] one of the {#DataAvailability} constants
+      #
+      def target_availability
+        raise NotImplementedError, "#{self.class} must implement #target_availability"
+      end
+
+      #
+      # Returns the data store used by the data system.
+      #
+      # @return [Object] The read-only store
+      #
+      def store
+        raise NotImplementedError, "#{self.class} must implement #store"
+      end
+
+      #
+      # Sets the diagnostic accumulator for streaming initialization metrics.
+      # This should be called before start() to ensure metrics are collected.
+      #
+      # @param diagnostic_accumulator [DiagnosticAccumulator] The diagnostic accumulator
+      # @return [void]
+      #
+      def set_diagnostic_accumulator(diagnostic_accumulator)
+        raise NotImplementedError, "#{self.class} must implement #set_diagnostic_accumulator"
+      end
+
+      #
+      # Represents the availability of data in the SDK.
+      #
+      class DataAvailability
+        # The SDK has no data and will evaluate flags using the application-provided default values.
+        DEFAULTS = :defaults
+
+        # The SDK has data, not necessarily the latest, which will be used to evaluate flags.
+        CACHED = :cached
+
+        # The SDK has obtained, at least once, the latest known data from LaunchDarkly.
+        REFRESHED = :refreshed
+
+        ALL = [DEFAULTS, CACHED, REFRESHED].freeze
+
+        #
+        # Returns whether this availability level is **at least** as good as the other.
+        #
+        # @param [Symbol] self_level The current availability level
+        # @param [Symbol] other The other availability level to compare against
+        # @return [Boolean] true if this availability level is at least as good as the other
+        #
+        def self.at_least?(self_level, other)
+          return true if self_level == other
+          return true if self_level == REFRESHED
+          return true if self_level == CACHED && other == DEFAULTS
+
+          false
+        end
+      end
+
+      #
+      # Mixin that defines the required methods of a diagnostic accumulator implementation.
+      # The diagnostic accumulator is used for collecting and reporting diagnostic events
+      # to LaunchDarkly for monitoring SDK performance and behavior.
+      #
+      # Application code should not need to implement this directly; it is used internally by the SDK.
+      #
+      module DiagnosticAccumulator
+        #
+        # Record a stream initialization.
+        #
+        # @param timestamp [Float] The timestamp
+        # @param duration [Float] The duration
+        # @param failed [Boolean] Whether it failed
+        # @return [void]
+        #
+        def record_stream_init(timestamp, duration, failed)
+          raise NotImplementedError, "#{self.class} must implement #record_stream_init"
+        end
+
+        #
+        # Record events in a batch.
+        #
+        # @param events_in_batch [Integer] The number of events
+        # @return [void]
+        #
+        def record_events_in_batch(events_in_batch)
+          raise NotImplementedError, "#{self.class} must implement #record_events_in_batch"
+        end
+
+        #
+        # Create an event and reset the accumulator.
+        #
+        # @param dropped_events [Integer] The number of dropped events
+        # @param deduplicated_users [Integer] The number of deduplicated users
+        # @return [Object] The diagnostic event
+        #
+        def create_event_and_reset(dropped_events, deduplicated_users)
+          raise NotImplementedError, "#{self.class} must implement #create_event_and_reset"
+        end
+      end
+
+      #
+      # Mixin that defines the required methods for components that can receive a diagnostic accumulator.
+      # Components that include this mixin can report diagnostic information to LaunchDarkly for
+      # monitoring SDK performance and behavior.
+      #
+      # Application code should not need to implement this directly; it is used internally by the SDK.
+      #
+      module DiagnosticSource
+        #
+        # Set the diagnostic_accumulator to be used for reporting diagnostic events.
+        #
+        # @param diagnostic_accumulator [DiagnosticAccumulator] The accumulator
+        # @return [void]
+        #
+        def set_diagnostic_accumulator(diagnostic_accumulator)
+          raise NotImplementedError, "#{self.class} must implement #set_diagnostic_accumulator"
+        end
+      end
+
+      #
+      # Mixin that defines the required methods of an initializer implementation. An initializer
+      # is a component capable of retrieving a single data result, such as from the LaunchDarkly
+      # polling API.
+      #
+      # The intent of initializers is to quickly fetch an initial set of data, which may be stale
+      # but is fast to retrieve. This initial data serves as a foundation for a Synchronizer to
+      # build upon, enabling it to provide updates as new changes occur.
+      #
+      # Application code should not need to implement this directly; it is used internally by the SDK.
+      #
+      module Initializer
+        #
+        # Fetch should retrieve the initial data set for the data source, returning
+        # a Basis object on success, or an error message on failure.
+        #
+        # @return [LaunchDarkly::Result] A Result containing either a Basis or an error message
+        #
+        def fetch
+          raise NotImplementedError, "#{self.class} must implement #fetch"
+        end
+      end
+
+      #
+      # Update represents the results of a synchronizer's ongoing sync method.
+      #
+      class Update
+        # @return [Symbol] The state of the data source
+        attr_reader :state
+
+        # @return [ChangeSet, nil] The change set if available
+        attr_reader :change_set
+
+        # @return [LaunchDarkly::Interfaces::DataSource::ErrorInfo, nil] Error information if applicable
+        attr_reader :error
+
+        # @return [Boolean] Whether to revert to FDv1
+        attr_reader :revert_to_fdv1
+
+        # @return [String, nil] The environment ID if available
+        attr_reader :environment_id
+
+        #
+        # @param state [Symbol] The state of the data source
+        # @param change_set [ChangeSet, nil] The change set if available
+        # @param error [LaunchDarkly::Interfaces::DataSource::ErrorInfo, nil] Error information if applicable
+        # @param revert_to_fdv1 [Boolean] Whether to revert to FDv1
+        # @param environment_id [String, nil] The environment ID if available
+        #
+        def initialize(state:, change_set: nil, error: nil, revert_to_fdv1: false, environment_id: nil)
+          @state = state
+          @change_set = change_set
+          @error = error
+          @revert_to_fdv1 = revert_to_fdv1
+          @environment_id = environment_id
+        end
+      end
+
+      #
+      # Mixin that defines the required methods of a synchronizer implementation. A synchronizer
+      # is a component capable of synchronizing data from an external data source, such as a
+      # streaming or polling API.
+      #
+      # It is responsible for yielding Update objects that represent the current state of the
+      # data source, including any changes that have occurred since the last synchronization.
+      #
+      # Application code should not need to implement this directly; it is used internally by the SDK.
+      #
+      module Synchronizer
+        #
+        # Sync should begin the synchronization process for the data source, yielding
+        # Update objects until the connection is closed or an unrecoverable error
+        # occurs.
+        #
+        # @yield [Update] Yields Update objects as synchronization progresses
+        # @return [void]
+        #
+        def sync
+          raise NotImplementedError, "#{self.class} must implement #sync"
+        end
+      end
+    end
+  end
+end
+

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

@@ -102,7 +102,7 @@ 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)

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/ldclient.rb

@@ -2,6 +2,7 @@ require "ldclient-rb/impl/big_segments"
 require "ldclient-rb/impl/broadcaster"
 require "ldclient-rb/impl/data_source"
 require "ldclient-rb/impl/data_store"
+require "ldclient-rb/impl/data_source/null_processor"
 require "ldclient-rb/impl/diagnostic_events"
 require "ldclient-rb/impl/evaluator"
 require "ldclient-rb/impl/evaluation_with_hook_result"
@@ -132,7 +133,7 @@ module LaunchDarkly
 
       if @config.use_ldd?
         @config.logger.info { "[LDClient] Started LaunchDarkly Client in LDD mode" }
-        @data_source = NullUpdateProcessor.new
+        @data_source = LaunchDarkly::Impl::DataSource::NullUpdateProcessor.new
         return  # requestor and update processor are not used in this mode
       end
 
@@ -710,7 +711,7 @@ module LaunchDarkly
 
     def create_default_data_source(sdk_key, config, diagnostic_accumulator)
       if config.offline?
-        return NullUpdateProcessor.new
+        return LaunchDarkly::Impl::DataSource::NullUpdateProcessor.new
       end
       raise ArgumentError, "sdk_key must not be nil" if sdk_key.nil?  # see LDClient constructor comment on sdk_key
       if config.stream?
@@ -877,23 +878,4 @@ module LaunchDarkly
       false
     end
   end
-
-  #
-  # Used internally when the client is offline.
-  # @private
-  #
-  class NullUpdateProcessor
-    def start
-      e = Concurrent::Event.new
-      e.set
-      e
-    end
-
-    def initialized?
-      true
-    end
-
-    def stop
-    end
-  end
 end

data/lib/ldclient-rb/stream.rb

@@ -25,6 +25,7 @@ module LaunchDarkly
     def initialize(sdk_key, config, diagnostic_accumulator = nil)
       @sdk_key = sdk_key
       @config = config
+      @diagnostic_accumulator = diagnostic_accumulator
       @data_source_update_sink = config.data_source_update_sink
       @feature_store = config.feature_store
       @initialized = Concurrent::AtomicBoolean.new(false)

data/lib/ldclient-rb/version.rb

@@ -1,3 +1,3 @@
 module LaunchDarkly
-  VERSION = "8.11.1" # x-release-please-version
+  VERSION = "8.11.2" # x-release-please-version
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: launchdarkly-server-sdk
 version: !ruby/object:Gem::Version
-  version: 8.11.1
+  version: 8.11.2
 platform: ruby
 authors:
 - LaunchDarkly
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2025-10-10 00:00:00.000000000 Z
+date: 2025-12-05 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: aws-sdk-dynamodb
@@ -24,6 +24,20 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '1.57'
+- !ruby/object:Gem::Dependency
+  name: bigdecimal
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 3.1.1
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 3.1.1
 - !ruby/object:Gem::Dependency
   name: bundler
   requirement: !ruby/object:Gem::Requirement
@@ -386,7 +400,10 @@ files:
 - lib/ldclient-rb/impl/context.rb
 - lib/ldclient-rb/impl/context_filter.rb
 - lib/ldclient-rb/impl/data_source.rb
+- lib/ldclient-rb/impl/data_source/null_processor.rb
 - lib/ldclient-rb/impl/data_store.rb
+- lib/ldclient-rb/impl/data_system.rb
+- lib/ldclient-rb/impl/data_system/fdv1.rb
 - lib/ldclient-rb/impl/dependency_tracker.rb
 - lib/ldclient-rb/impl/diagnostic_events.rb
 - lib/ldclient-rb/impl/evaluation_with_hook_result.rb