launchdarkly-server-sdk 8.11.2 → 8.11.3

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

@@ -0,0 +1,187 @@
+# frozen_string_literal: true
+
+require "concurrent"
+require "ldclient-rb/interfaces"
+require "ldclient-rb/impl/store_data_set_sorter"
+require "ldclient-rb/impl/repeating_task"
+
+module LaunchDarkly
+  module Impl
+    module DataStore
+      #
+      # Provides additional behavior that the client requires before or after feature store operations.
+      # Currently this just means sorting the data set for init() and dealing with data store status listeners.
+      #
+      class FeatureStoreClientWrapperV2
+        include LaunchDarkly::Interfaces::FeatureStore
+
+        #
+        # Initialize the wrapper.
+        #
+        # @param store [LaunchDarkly::Interfaces::FeatureStore] The underlying feature store
+        # @param store_update_sink [LaunchDarkly::Impl::DataStore::StatusProviderV2] The status provider for updates
+        # @param logger [Logger] The logger instance
+        #
+        def initialize(store, store_update_sink, logger)
+          @store = store
+          @store_update_sink = store_update_sink
+          @logger = logger
+          @monitoring_enabled = store_supports_monitoring?
+
+          # Thread synchronization
+          @mutex = Mutex.new
+          @last_available = true
+          @poller = nil
+          @closed = false
+        end
+
+        # (see LaunchDarkly::Interfaces::FeatureStore#init)
+        def init(all_data)
+          wrapper { @store.init(FeatureStoreDataSetSorter.sort_all_collections(all_data)) }
+        end
+
+        # (see LaunchDarkly::Interfaces::FeatureStore#get)
+        def get(kind, key)
+          wrapper { @store.get(kind, key) }
+        end
+
+        # (see LaunchDarkly::Interfaces::FeatureStore#all)
+        def all(kind)
+          wrapper { @store.all(kind) }
+        end
+
+        # (see LaunchDarkly::Interfaces::FeatureStore#delete)
+        def delete(kind, key, version)
+          wrapper { @store.delete(kind, key, version) }
+        end
+
+        # (see LaunchDarkly::Interfaces::FeatureStore#upsert)
+        def upsert(kind, item)
+          wrapper { @store.upsert(kind, item) }
+        end
+
+        # (see LaunchDarkly::Interfaces::FeatureStore#initialized?)
+        def initialized?
+          @store.initialized?
+        end
+
+        # (see LaunchDarkly::Interfaces::FeatureStore#stop)
+        def stop
+          poller_to_stop = nil
+
+          @mutex.synchronize do
+            return if @closed
+
+            @closed = true
+            poller_to_stop = @poller
+            @poller = nil
+          end
+
+          poller_to_stop.stop if poller_to_stop
+
+          @store.stop
+        end
+
+        #
+        # Returns whether monitoring is enabled.
+        #
+        # @return [Boolean]
+        #
+        def monitoring_enabled?
+          @monitoring_enabled
+        end
+
+        #
+        # Wraps store operations with exception handling and availability tracking.
+        #
+        # @yield The block to execute
+        # @return [Object] The result of the block
+        #
+        private def wrapper
+          begin
+            yield
+          rescue StandardError
+            update_availability(false) if @monitoring_enabled
+            raise
+          end
+        end
+
+        #
+        # Updates the availability status of the store.
+        #
+        # @param available [Boolean] Whether the store is available
+        # @return [void]
+        #
+        private def update_availability(available)
+          state_changed = false
+          poller_to_stop = nil
+
+          @mutex.synchronize do
+            return if @closed
+            return if available == @last_available
+
+            state_changed = true
+            @last_available = available
+
+            if available
+              poller_to_stop = @poller
+              @poller = nil
+            elsif @poller.nil?
+              task = LaunchDarkly::Impl::RepeatingTask.new(0.5, 0, method(:check_availability), @logger, "LDClient/DataStoreWrapperV2#check-availability")
+              @poller = task
+              @poller.start
+            end
+          end
+
+          return unless state_changed
+
+          if available
+            @logger.warn { "[LDClient] Persistent store is available again" }
+          else
+            @logger.warn { "[LDClient] Detected persistent store unavailability; updates will be cached until it recovers" }
+          end
+
+          status = LaunchDarkly::Interfaces::DataStore::Status.new(available, true)
+          @store_update_sink.update_status(status)
+
+          poller_to_stop.stop if poller_to_stop
+        end
+
+        #
+        # Checks if the store is available.
+        #
+        # @return [void]
+        #
+        private def check_availability
+          begin
+            update_availability(true) if @store.available?
+          rescue => e
+            @logger.error { "[LDClient] Unexpected error from data store status function: #{e.message}" }
+          end
+        end
+
+        #
+        # Determines whether the wrapped store can support enabling monitoring.
+        #
+        # The wrapped store must provide a monitoring_enabled? method, which must
+        # be true. But this alone is not sufficient.
+        #
+        # Because this class wraps all interactions with a provided store, it can
+        # technically "monitor" any store. However, monitoring also requires that
+        # we notify listeners when the store is available again.
+        #
+        # We determine this by checking the store's available? method, so this
+        # is also a requirement for monitoring support.
+        #
+        # @return [Boolean]
+        #
+        private def store_supports_monitoring?
+          return false unless @store.respond_to?(:monitoring_enabled?)
+          return false unless @store.respond_to?(:available?)
+
+          @store.monitoring_enabled?
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,130 @@
+# frozen_string_literal: true
+
+require "concurrent"
+require "concurrent/atomics"
+require "ldclient-rb/impl/data_store"
+require "ldclient-rb/interfaces/data_system"
+
+module LaunchDarkly
+  module Impl
+    module DataStore
+      #
+      # InMemoryFeatureStoreV2 is a read-only in-memory store implementation for FDv2.
+      #
+      class InMemoryFeatureStoreV2
+        include LaunchDarkly::Interfaces::DataSystem::ReadOnlyStore
+        def initialize(logger)
+          @logger = logger
+          @lock = Concurrent::ReadWriteLock.new
+          @initialized = Concurrent::AtomicBoolean.new(false)
+          @items = {}
+        end
+
+        #
+        # (see LaunchDarkly::Interfaces::DataSystem::ReadOnlyStore#get)
+        #
+        def get(kind, key)
+          @lock.with_read_lock do
+            items_of_kind = @items[kind]
+            return nil if items_of_kind.nil?
+
+            item = items_of_kind[key]
+            return nil if item.nil?
+            return nil if item[:deleted]
+
+            item
+          end
+        end
+
+        #
+        # (see LaunchDarkly::Interfaces::DataSystem::ReadOnlyStore#all)
+        #
+        def all(kind)
+          @lock.with_read_lock do
+            items_of_kind = @items[kind]
+            return {} if items_of_kind.nil?
+
+            items_of_kind.select { |_k, item| !item[:deleted] }
+          end
+        end
+
+        #
+        # (see LaunchDarkly::Interfaces::DataSystem::ReadOnlyStore#initialized?)
+        #
+        def initialized?
+          @initialized.value
+        end
+
+        #
+        # Initializes the store with a full set of data, replacing any existing data.
+        #
+        # @param collections [Hash<LaunchDarkly::Impl::DataStore::DataKind, Hash<String, Hash>>] Hash of data kinds to collections of items
+        # @return [Boolean] true if successful, false otherwise
+        #
+        def set_basis(collections)
+          all_decoded = decode_collection(collections)
+          return false if all_decoded.nil?
+
+          @lock.with_write_lock do
+            @items.clear
+            @items.update(all_decoded)
+            @initialized.make_true
+          end
+
+          true
+        rescue => e
+          @logger.error { "[LDClient] Failed applying set_basis: #{e.message}" }
+          false
+        end
+
+        #
+        # Applies a delta update to the store.
+        #
+        # @param collections [Hash<LaunchDarkly::Impl::DataStore::DataKind, Hash<String, Hash>>] Hash of data kinds to collections with updates
+        # @return [Boolean] true if successful, false otherwise
+        #
+        def apply_delta(collections)
+          all_decoded = decode_collection(collections)
+          return false if all_decoded.nil?
+
+          @lock.with_write_lock do
+            all_decoded.each do |kind, kind_data|
+              items_of_kind = @items[kind] ||= {}
+              kind_data.each do |key, item|
+                items_of_kind[key] = item
+              end
+            end
+          end
+
+          true
+        rescue => e
+          @logger.error { "[LDClient] Failed applying apply_delta: #{e.message}" }
+          false
+        end
+
+        #
+        # Decodes a collection of items.
+        #
+        # @param collections [Hash<LaunchDarkly::Impl::DataStore::DataKind, Hash<String, Hash>>] Hash of data kinds to collections
+        # @return [Hash<LaunchDarkly::Impl::DataStore::DataKind, Hash<Symbol, Hash>>, nil] Decoded collection with symbol keys, or nil on error
+        #
+        private def decode_collection(collections)
+          all_decoded = {}
+
+          collections.each do |kind, collection|
+            items_decoded = {}
+            collection.each do |key, item|
+              items_decoded[key] = LaunchDarkly::Impl::Model.deserialize(kind, item, @logger)
+            end
+            all_decoded[kind] = items_decoded
+          end
+
+          all_decoded
+        rescue => e
+          @logger.error { "[LDClient] Failed decoding collection: #{e.message}" }
+          nil
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,82 @@
+# frozen_string_literal: true
+
+require "concurrent"
+require "forwardable"
+require "ldclient-rb/interfaces"
+
+module LaunchDarkly
+  module Impl
+    module DataStore
+      #
+      # StatusProviderV2 is the FDv2-specific implementation of {LaunchDarkly::Interfaces::DataStore::StatusProvider}.
+      #
+      # This type is not stable, and not subject to any backwards
+      # compatibility guarantees or semantic versioning. It is not suitable for production usage.
+      #
+      # Do not use it.
+      # You have been warned.
+      #
+      class StatusProviderV2
+        include LaunchDarkly::Interfaces::DataStore::StatusProvider
+
+        extend Forwardable
+        def_delegators :@status_broadcaster, :add_listener, :remove_listener
+
+        #
+        # Initialize the status provider.
+        #
+        # @param store [Object, nil] The feature store (may be nil for in-memory only)
+        # @param status_broadcaster [LaunchDarkly::Impl::Broadcaster] Broadcaster for status changes
+        #
+        def initialize(store, status_broadcaster)
+          @store = store
+          @status_broadcaster = status_broadcaster
+          @lock = Concurrent::ReadWriteLock.new
+          @status = LaunchDarkly::Interfaces::DataStore::Status.new(true, false)
+          @monitoring_enabled = store_supports_monitoring?
+        end
+
+        # (see LaunchDarkly::Interfaces::DataStore::UpdateSink#update_status)
+        def update_status(status)
+          modified = false
+
+          @lock.with_write_lock do
+            if @status.available != status.available || @status.stale != status.stale
+              @status = status
+              modified = true
+            end
+          end
+
+          @status_broadcaster.broadcast(status) if modified
+        end
+
+        # (see LaunchDarkly::Interfaces::DataStore::StatusProvider#status)
+        def status
+          @lock.with_read_lock do
+            LaunchDarkly::Interfaces::DataStore::Status.new(@status.available, @status.stale)
+          end
+        end
+
+        # (see LaunchDarkly::Interfaces::DataStore::StatusProvider#monitoring_enabled?)
+        def monitoring_enabled?
+          @monitoring_enabled
+        end
+
+        #
+        # Determines whether the store supports monitoring.
+        #
+        # @return [Boolean]
+        #
+        private def store_supports_monitoring?
+          return false if @store.nil?
+          return false unless @store.respond_to?(:monitoring_enabled?)
+
+          @store.monitoring_enabled?
+        end
+      end
+    end
+  end
+end
+
+
+