launchdarkly-server-sdk 7.1.0 → 7.3.0

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

@@ -1,3 +1,4 @@
+require "ldclient-rb/interfaces"
 require "concurrent/atomics"
 require "json"
 
@@ -42,6 +43,14 @@ module LaunchDarkly
             @wrapper = LaunchDarkly::Integrations::Util::CachingStoreWrapper.new(core, opts)
           end
 
+          def monitoring_enabled?
+            true
+          end
+
+          def available?
+            @wrapper.available?
+          end
+
           #
           # Default value for the `redis_url` constructor parameter; points to an instance of Redis
           # running at `localhost` with its default port.
@@ -109,7 +118,7 @@ module LaunchDarkly
             @logger = opts[:logger] || Config.default_logger
             @test_hook = opts[:test_hook]  # used for unit tests, deliberately undocumented
 
-            @stopped = Concurrent::AtomicBoolean.new()
+            @stopped = Concurrent::AtomicBoolean.new
 
             with_connection do |redis|
               @logger.info("#{description}: using Redis instance at #{redis.connection[:host]}:#{redis.connection[:port]} and prefix: #{@prefix}")
@@ -154,6 +163,14 @@ module LaunchDarkly
             @test_hook = opts[:test_hook]  # used for unit tests, deliberately undocumented
           end
 
+          def available?
+            # We don't care what the status is, only that we can connect
+            initialized_internal?
+            true
+          rescue
+            false
+          end
+
           def description
             "RedisFeatureStore"
           end

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

@@ -16,9 +16,8 @@ module LaunchDarkly
 
       def start
         @worker = Thread.new do
-          if @start_delay
-            sleep(@start_delay)
-          end
+          sleep(@start_delay) unless @start_delay.nil? || @start_delay == 0
+
           until @stopped.value do
             started_at = Time.now
             begin

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

@@ -1,3 +1,4 @@
+require "concurrent"
 require "ldclient-rb/interfaces"
 require "ldclient-rb/impl/store_data_set_sorter"
 
@@ -5,34 +6,45 @@ module LaunchDarkly
   module Impl
     #
     # Provides additional behavior that the client requires before or after feature store operations.
-    # Currently this just means sorting the data set for init(). In the future we may also use this
-    # to provide an update listener capability.
+    # This just means sorting the data set for init() and dealing with data store status listeners.
     #
     class FeatureStoreClientWrapper
       include Interfaces::FeatureStore
 
-      def initialize(store)
+      def initialize(store, store_update_sink, logger)
+        # @type [LaunchDarkly::Interfaces::FeatureStore]
         @store = store
+
+        @monitoring_enabled = does_store_support_monitoring?
+
+        # @type [LaunchDarkly::Impl::DataStore::UpdateSink]
+        @store_update_sink = store_update_sink
+        @logger = logger
+
+        @mutex = Mutex.new # Covers the following variables
+        @last_available = true
+        # @type [LaunchDarkly::Impl::RepeatingTask, nil]
+        @poller = nil
       end
 
       def init(all_data)
-        @store.init(FeatureStoreDataSetSorter.sort_all_collections(all_data))
+        wrapper { @store.init(FeatureStoreDataSetSorter.sort_all_collections(all_data)) }
       end
 
       def get(kind, key)
-        @store.get(kind, key)
+        wrapper { @store.get(kind, key) }
       end
 
       def all(kind)
-        @store.all(kind)
+        wrapper { @store.all(kind) }
       end
 
       def upsert(kind, item)
-        @store.upsert(kind, item)
+        wrapper { @store.upsert(kind, item) }
       end
 
       def delete(kind, key, version)
-        @store.delete(kind, key, version)
+        wrapper { @store.delete(kind, key, version) }
       end
 
       def initialized?
@@ -41,6 +53,88 @@ module LaunchDarkly
 
       def stop
         @store.stop
+        @mutex.synchronize do
+          return if @poller.nil?
+
+          @poller.stop
+          @poller = nil
+        end
+      end
+
+      def monitoring_enabled?
+        @monitoring_enabled
+      end
+
+      private def wrapper()
+        begin
+          yield
+        rescue => e
+          update_availability(false) if @monitoring_enabled
+          raise
+        end
+      end
+
+      private def update_availability(available)
+        @mutex.synchronize do
+          return if available == @last_available
+          @last_available = available
+        end
+
+        status = LaunchDarkly::Interfaces::DataStore::Status.new(available, false)
+
+        @logger.warn("Persistent store is available again") if available
+
+        @store_update_sink.update_status(status)
+
+        if available
+          @mutex.synchronize do
+            return if @poller.nil?
+
+            @poller.stop
+            @poller = nil
+          end
+
+          return
+        end
+
+        @logger.warn("Detected persistent store unavailability; updates will be cached until it recovers.")
+
+        task = Impl::RepeatingTask.new(0.5, 0, -> { self.check_availability }, @logger)
+
+        @mutex.synchronize do
+          @poller = task
+          @poller.start
+        end
+      end
+
+      private def check_availability
+        begin
+          update_availability(true) if @store.available?
+        rescue => e
+          @logger.error("Unexpected error from data store status function: #{e}")
+        end
+      end
+
+      # This methods 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.
+      #
+      # These extra checks won't be necessary once `available` becomes a part
+      # of the core interface requirements and this class no longer wraps every
+      # feature store.
+      private def does_store_support_monitoring?
+        return false unless @store.respond_to? :monitoring_enabled?
+        return false unless @store.respond_to? :available?
+
+        @store.monitoring_enabled?
       end
     end
   end

data/lib/ldclient-rb/in_memory_store.rb

@@ -23,6 +23,9 @@ module LaunchDarkly
     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.
@@ -37,6 +40,10 @@ module LaunchDarkly
       @initialized = Concurrent::AtomicBoolean.new(false)
     end
 
+    def monitoring_enabled?
+      false
+    end
+
     def get(kind, key)
       @lock.with_read_lock do
         coll = @items[kind]

data/lib/ldclient-rb/integrations/file_data.rb

@@ -101,7 +101,7 @@ module LaunchDarkly
       #
       def self.data_source(options={})
         lambda { |sdk_key, config|
-          Impl::Integrations::FileDataSourceImpl.new(config.feature_store, config.logger, options) }
+          Impl::Integrations::FileDataSourceImpl.new(config.feature_store, config.data_source_update_sink, config.logger, options) }
       end
     end
   end

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

@@ -90,7 +90,7 @@ module LaunchDarkly
       #
       def flag(key)
         existing_builder = @lock.with_read_lock { @flag_builders[key] }
-        if existing_builder.nil? then
+        if existing_builder.nil?
           FlagBuilder.new(key).boolean_flag
         else
           existing_builder.clone
@@ -118,7 +118,7 @@ module LaunchDarkly
           @flag_builders[flag_builder.key] = flag_builder
           version = 0
           flag_key = flag_builder.key.to_sym
-          if @current_flags[flag_key] then
+          if @current_flags[flag_key]
             version = @current_flags[flag_key][:version]
           end
           new_flag = Impl::Model.deserialize(FEATURES, flag_builder.build(version+1))
@@ -175,7 +175,7 @@ module LaunchDarkly
         key = item.key.to_sym
         @lock.with_write_lock do
           old_item = current[key]
-          unless old_item.nil? then
+          unless old_item.nil?
             data = item.as_json
             data[:version] = old_item.version + 1
             item = Impl::Model.deserialize(kind, data)

data/lib/ldclient-rb/integrations/util/store_wrapper.rb

@@ -43,6 +43,17 @@ module LaunchDarkly
           end
 
           @inited = Concurrent::AtomicBoolean.new(false)
+          @has_available_method = @core.respond_to? :available?
+        end
+
+        def monitoring_enabled?
+          @has_available_method
+        end
+
+        def available?
+          return false unless @has_available_method
+
+          @core.available?
         end
 
         def init(all_data)