launchdarkly-server-sdk 8.11.1 → 8.11.3

data/lib/ldclient-rb/impl/data_store/store.rb

@@ -0,0 +1,371 @@
+# frozen_string_literal: true
+
+require "concurrent"
+require "set"
+require "ldclient-rb/impl/data_store"
+require "ldclient-rb/impl/data_store/in_memory_feature_store"
+require "ldclient-rb/impl/dependency_tracker"
+require "ldclient-rb/interfaces/data_system"
+
+module LaunchDarkly
+  module Impl
+    module DataStore
+      #
+      # Store is a dual-mode persistent/in-memory store that serves requests for
+      # data from the evaluation algorithm.
+      #
+      # At any given moment one of two stores is active: in-memory, or persistent.
+      # Once the in-memory store has data (either from initializers or a
+      # synchronizer), the persistent store is no longer read from. From that point
+      # forward, calls to get data will serve from the memory store.
+      #
+      class Store
+        include LaunchDarkly::Interfaces::DataSystem::SelectorStore
+
+        #
+        # Initialize a new Store.
+        #
+        # @param flag_change_broadcaster [LaunchDarkly::Impl::Broadcaster] Broadcaster for flag change events
+        # @param change_set_broadcaster [LaunchDarkly::Impl::Broadcaster] Broadcaster for changeset events
+        # @param logger [Logger] The logger instance
+        #
+        def initialize(flag_change_broadcaster, change_set_broadcaster, logger)
+          @logger = logger
+          @persistent_store = nil
+          @persistent_store_status_provider = nil
+          @persistent_store_writable = false
+
+          # Source of truth for flag evaluations once initialized
+          @memory_store = InMemoryFeatureStoreV2.new(logger)
+
+          # Used to track dependencies between items in the store
+          @dependency_tracker = LaunchDarkly::Impl::DependencyTracker.new(logger)
+
+          # Broadcasters for events
+          @flag_change_broadcaster = flag_change_broadcaster
+          @change_set_broadcaster = change_set_broadcaster
+
+          # True if the data in the memory store may be persisted to the persistent store
+          @persist = false
+
+          # Points to the active store. Swapped upon initialization.
+          @active_store = @memory_store
+
+          # Identifies the current data
+          @selector = LaunchDarkly::Interfaces::DataSystem::Selector.no_selector
+
+          # Thread synchronization
+          @lock = Mutex.new
+        end
+
+        #
+        # Configure the store with a persistent store for read-only or read-write access.
+        #
+        # @param persistent_store [LaunchDarkly::Interfaces::FeatureStore] The persistent store implementation
+        # @param writable [Boolean] Whether the persistent store should be written to
+        # @param status_provider [LaunchDarkly::Impl::DataStore::StatusProviderV2, nil] Optional status provider for the persistent store
+        # @return [Store] self for method chaining
+        #
+        def with_persistence(persistent_store, writable, status_provider = nil)
+          @lock.synchronize do
+            @persistent_store = persistent_store
+            @persistent_store_writable = writable
+            @persistent_store_status_provider = status_provider
+
+            # Initially use persistent store as active until memory store has data
+            @active_store = persistent_store
+          end
+
+          self
+        end
+
+        # (see LaunchDarkly::Interfaces::DataSystem::SelectorStore#selector)
+        def selector
+          @lock.synchronize do
+            @selector
+          end
+        end
+
+        #
+        # Close the store and any persistent store if configured.
+        #
+        # @return [Exception, nil] Exception if close failed, nil otherwise
+        #
+        def close
+          @lock.synchronize do
+            return nil if @persistent_store.nil?
+
+            begin
+              @persistent_store.stop if @persistent_store.respond_to?(:stop)
+            rescue => e
+              return e
+            end
+          end
+
+          nil
+        end
+
+        #
+        # Apply a changeset to the store.
+        #
+        # @param change_set [LaunchDarkly::Interfaces::DataSystem::ChangeSet] The changeset to apply
+        # @param persist [Boolean] Whether the changes should be persisted to the persistent store
+        # @return [void]
+        #
+        def apply(change_set, persist)
+          collections = changes_to_store_data(change_set.changes)
+
+          @lock.synchronize do
+            begin
+              case change_set.intent_code
+              when LaunchDarkly::Interfaces::DataSystem::IntentCode::TRANSFER_FULL
+                set_basis(collections, change_set.selector, persist)
+              when LaunchDarkly::Interfaces::DataSystem::IntentCode::TRANSFER_CHANGES
+                apply_delta(collections, change_set.selector, persist)
+              when LaunchDarkly::Interfaces::DataSystem::IntentCode::TRANSFER_NONE
+                # No-op, no changes to apply
+                return
+              end
+
+              # Notify changeset listeners
+              @change_set_broadcaster.broadcast(change_set)
+            rescue => e
+              @logger.error { "[LDClient] Couldn't apply changeset: #{e.message}" }
+            end
+          end
+        end
+
+        #
+        # Commit persists the data in the memory store to the persistent store, if configured.
+        #
+        # @return [Exception, nil] Exception if commit failed, nil otherwise
+        #
+        def commit
+          @lock.synchronize do
+            return nil unless should_persist?
+
+            begin
+              # Get all data from memory store and write to persistent store
+              all_data = {}
+              [FEATURES, SEGMENTS].each do |kind|
+                all_data[kind] = @memory_store.all(kind)
+              end
+              @persistent_store.init(all_data)
+            rescue => e
+              return e
+            end
+          end
+
+          nil
+        end
+
+        #
+        # Get the currently active store for reading data.
+        #
+        # @return [LaunchDarkly::Interfaces::FeatureStore] The active store (memory or persistent)
+        #
+        def get_active_store
+          @lock.synchronize do
+            @active_store
+          end
+        end
+
+        #
+        # Check if the active store is initialized.
+        #
+        # @return [Boolean]
+        #
+        def initialized?
+          get_active_store.initialized?
+        end
+
+        #
+        # Get the data store status provider for the persistent store, if configured.
+        #
+        # @return [LaunchDarkly::Impl::DataStore::StatusProviderV2, nil] The data store status provider for the persistent store, if configured
+        #
+        def get_data_store_status_provider
+          @lock.synchronize do
+            @persistent_store_status_provider
+          end
+        end
+
+        #
+        # Set the basis of the store. Any existing data is discarded.
+        #
+        # @param collections [Hash{Object => Hash{String => Hash}}] Hash of data kinds to collections of items
+        # @param selector [LaunchDarkly::Interfaces::DataSystem::Selector, nil] The selector
+        # @param persist [Boolean] Whether to persist the data
+        # @return [void]
+        #
+        private def set_basis(collections, selector, persist)
+          # Take snapshot for change detection if we have flag listeners
+          old_data = nil
+          if @flag_change_broadcaster.has_listeners?
+            old_data = {}
+            [FEATURES, SEGMENTS].each do |kind|
+              old_data[kind] = @memory_store.all(kind)
+            end
+          end
+
+          ok = @memory_store.set_basis(collections)
+          return unless ok
+
+          # Update dependency tracker
+          reset_dependency_tracker(collections)
+
+          # Update state
+          @persist = persist
+          @selector = selector || LaunchDarkly::Interfaces::DataSystem::Selector.no_selector
+
+          # Switch to memory store as active
+          @active_store = @memory_store
+
+          # Persist to persistent store if configured and writable
+          @persistent_store.init(collections) if should_persist?
+
+          # Send change events if we had listeners
+          if old_data
+            affected_items = compute_changed_items_for_full_data_set(old_data, collections)
+            send_change_events(affected_items)
+          end
+        end
+
+        #
+        # Apply a delta update to the store.
+        #
+        # @param collections [Hash{Object => Hash{String => Hash}}] Hash of data kinds to collections with updates
+        # @param selector [LaunchDarkly::Interfaces::DataSystem::Selector, nil] The selector
+        # @param persist [Boolean] Whether to persist the changes
+        # @return [void]
+        #
+        private def apply_delta(collections, selector, persist)
+          ok = @memory_store.apply_delta(collections)
+          return unless ok
+
+          has_listeners = @flag_change_broadcaster.has_listeners?
+          affected_items = Set.new
+
+          collections.each do |kind, collection|
+            collection.each do |key, item|
+              @dependency_tracker.update_dependencies_from(kind, key, item)
+              if has_listeners
+                @dependency_tracker.add_affected_items(affected_items, { kind: kind, key: key })
+              end
+            end
+          end
+
+          # Update state
+          @persist = persist
+          @selector = selector || LaunchDarkly::Interfaces::DataSystem::Selector.no_selector
+
+          if should_persist?
+            collections.each do |kind, kind_data|
+              kind_data.each do |_key, item|
+                @persistent_store.upsert(kind, item)
+              end
+            end
+          end
+
+          # Send change events
+          send_change_events(affected_items) unless affected_items.empty?
+        end
+
+        #
+        # Returns whether data should be persisted to the persistent store.
+        #
+        # @return [Boolean]
+        #
+        private def should_persist?
+          @persist && !@persistent_store.nil? && @persistent_store_writable
+        end
+
+        #
+        # Convert a list of Changes to the pre-existing format used by FeatureStore.
+        #
+        # @param changes [Array<LaunchDarkly::Interfaces::DataSystem::Change>] List of changes
+        # @return [Hash{DataKind => Hash{String => Hash}}] Hash suitable for FeatureStore operations
+        #
+        private def changes_to_store_data(changes)
+          all_data = {
+            FEATURES => {},
+            SEGMENTS => {},
+          }
+
+          changes.each do |change|
+            kind = change.kind == LaunchDarkly::Interfaces::DataSystem::ObjectKind::FLAG ? FEATURES : SEGMENTS
+            if change.action == LaunchDarkly::Interfaces::DataSystem::ChangeType::PUT && !change.object.nil?
+              all_data[kind][change.key] = change.object
+            elsif change.action == LaunchDarkly::Interfaces::DataSystem::ChangeType::DELETE
+              all_data[kind][change.key] = { key: change.key, deleted: true, version: change.version }
+            end
+          end
+
+          all_data
+        end
+
+        #
+        # Reset dependency tracker with new full data set.
+        #
+        # @param all_data [Hash{DataKind => Hash{String => Hash}}] Hash of data kinds to items
+        # @return [void]
+        #
+        private def reset_dependency_tracker(all_data)
+          @dependency_tracker.reset
+          all_data.each do |kind, items|
+            items.each do |key, item|
+              @dependency_tracker.update_dependencies_from(kind, key, item)
+            end
+          end
+        end
+
+        #
+        # Send flag change events for affected items.
+        #
+        # @param affected_items [Set<Hash>] Set of {kind:, key:} hashes
+        # @return [void]
+        #
+        private def send_change_events(affected_items)
+          affected_items.each do |item|
+            if item[:kind] == FEATURES
+              @flag_change_broadcaster.broadcast(LaunchDarkly::Interfaces::FlagChange.new(item[:key]))
+            end
+          end
+        end
+
+        #
+        # Compute which items changed between old and new data sets.
+        #
+        # @param old_data [Hash{DataKind => Hash{String => Hash}}] Old data hash
+        # @param new_data [Hash{DataKind => Hash{String => Hash}}] New data hash
+        # @return [Set<Hash>] Set of {kind:, key:} hashes
+        #
+        private def compute_changed_items_for_full_data_set(old_data, new_data)
+          affected_items = Set.new
+
+          [FEATURES, SEGMENTS].each do |kind|
+            old_items = old_data[kind] || {}
+            new_items = new_data[kind] || {}
+
+            # Get all keys from both old and new data
+            all_keys = Set.new(old_items.keys) | Set.new(new_items.keys)
+
+            all_keys.each do |key|
+              old_item = old_items[key]
+              new_item = new_items[key]
+
+              # If either is missing or versions differ, it's a change
+              if old_item.nil? || new_item.nil?
+                @dependency_tracker.add_affected_items(affected_items, { kind: kind, key: key })
+              elsif old_item[:version] != new_item[:version]
+                @dependency_tracker.add_affected_items(affected_items, { kind: kind, key: key })
+              end
+            end
+          end
+
+          affected_items
+        end
+      end
+    end
+  end
+end

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

@@ -1,109 +1,23 @@
 require 'concurrent'
 require "ldclient-rb/interfaces"
+require "ldclient-rb/impl/data_store/data_kind"
 
 module LaunchDarkly
   module Impl
     module DataStore
-
-      class DataKind
-        FEATURES = "features".freeze
-        SEGMENTS = "segments".freeze
-
-        FEATURE_PREREQ_FN = lambda { |flag| (flag[:prerequisites] || []).map { |p| p[:key] } }.freeze
-
-        attr_reader :namespace
-        attr_reader :priority
-
-        #
-        # @param namespace [String]
-        # @param priority [Integer]
-        #
-        def initialize(namespace:, priority:)
-          @namespace = namespace
-          @priority = priority
-        end
-
-        #
-        # Maintain the same behavior when these data kinds were standard ruby hashes.
-        #
-        # @param key [Symbol]
-        # @return [Object]
-        #
-        def [](key)
-          return priority if key == :priority
-          return namespace if key == :namespace
-          return get_dependency_keys_fn() if key == :get_dependency_keys
-          nil
-        end
-
-        #
-        # Retrieve the dependency keys for a particular data kind. Right now, this is only defined for flags.
+        # 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.
         #
-        def get_dependency_keys_fn()
-          return nil unless @namespace == FEATURES
-
-          FEATURE_PREREQ_FN
-        end
-
-        def eql?(other)
-          other.is_a?(DataKind) && namespace == other.namespace && priority == other.priority
-        end
-
-        def hash
-          [namespace, priority].hash
-        end
-      end
-
-      class StatusProvider
-        include LaunchDarkly::Interfaces::DataStore::StatusProvider
-
-        def initialize(store, update_sink)
-          # @type [LaunchDarkly::Impl::FeatureStoreClientWrapper]
-          @store = store
-          # @type [UpdateSink]
-          @update_sink = update_sink
-        end
-
-        def status
-          @update_sink.last_status.get
-        end
-
-        def monitoring_enabled?
-          @store.monitoring_enabled?
-        end
-
-        def add_listener(listener)
-          @update_sink.broadcaster.add_listener(listener)
-        end
-
-        def remove_listener(listener)
-          @update_sink.broadcaster.remove_listener(listener)
-        end
-      end
-
-      class UpdateSink
-        include LaunchDarkly::Interfaces::DataStore::UpdateSink
-
-        # @return [LaunchDarkly::Impl::Broadcaster]
-        attr_reader :broadcaster
-
-        # @return [Concurrent::AtomicReference]
-        attr_reader :last_status
+        # The :priority and :get_dependency_keys properties are used by FeatureStoreDataSetSorter
+        # to ensure data consistency during non-atomic updates.
 
-        def initialize(broadcaster)
-          @broadcaster = broadcaster
-          @last_status = Concurrent::AtomicReference.new(
-            LaunchDarkly::Interfaces::DataStore::Status.new(true, false)
-          )
-        end
+        FEATURES = DataKind.new(namespace: "features", priority: 1).freeze
 
-        def update_status(status)
-          return if status.nil?
+        SEGMENTS = DataKind.new(namespace: "segments", priority: 0).freeze
 
-          old_status = @last_status.get_and_set(status)
-          @broadcaster.broadcast(status) unless old_status == status
-        end
-      end
+        ALL_KINDS = [FEATURES, SEGMENTS].freeze
     end
   end
-end
+end

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

@@ -0,0 +1,178 @@
+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_source/polling'
+require 'ldclient-rb/impl/data_source/requestor'
+require 'ldclient-rb/impl/data_source/stream'
+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
+          )
+
+          # Preserve the original unwrapped store to avoid nested wrappers on postfork
+          original_store = @config.feature_store
+          if original_store.is_a?(LaunchDarkly::Impl::FeatureStoreClientWrapper)
+            original_store = original_store.instance_variable_get(:@store)
+          end
+
+          # Wrap the original data store with client wrapper (must be created before status provider)
+          @store_wrapper = LaunchDarkly::Impl::FeatureStoreClientWrapper.new(
+            original_store,
+            @data_store_update_sink,
+            @config.logger
+          )
+
+          # Update config to use wrapped store so data sources can access it
+          @config.instance_variable_set(:@feature_store, @store_wrapper)
+
+          # 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
+          @store_wrapper.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?
+            return LaunchDarkly::Impl::DataSource::StreamProcessor.new(@sdk_key, @config, @diagnostic_accumulator)
+          end
+
+          # Polling processor
+          @config.logger.info { "Disabling streaming API" }
+          @config.logger.warn { "You should only disable the streaming API if instructed to do so by LaunchDarkly support" }
+          requestor = LaunchDarkly::Impl::DataSource::Requestor.new(@sdk_key, @config)
+          LaunchDarkly::Impl::DataSource::PollingProcessor.new(@config, requestor)
+        end
+      end
+    end
+  end
+end
+