launchdarkly-server-sdk 7.0.2 → 8.4.2

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

@@ -0,0 +1,25 @@
+module LaunchDarkly
+  module Impl
+    class Sampler
+      #
+      # @param random [Random]
+      #
+      def initialize(random)
+        @random = random
+      end
+
+      #
+      # @param ratio [Int]
+      #
+      # @return [Boolean]
+      #
+      def sample(ratio)
+        return false unless ratio.is_a? Integer
+        return false if ratio <= 0
+        return true if ratio == 1
+
+        @random.rand(1.0) < 1.0 / ratio
+      end
+    end
+  end
+end

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

@@ -43,6 +43,47 @@ module LaunchDarkly
           self
         end
 
+        #
+        # Set the migration related settings for this feature flag.
+        #
+        # The settings hash should be built using the {FlagMigrationSettingsBuilder}.
+        #
+        # @param settings [Hash]
+        # @return [FlagBuilder] the builder
+        #
+        def migration_settings(settings)
+          @migration_settings = settings
+          self
+        end
+
+        #
+        # Set the sampling ratio for this flag. This ratio is used to control the emission rate of feature, debug, and
+        # migration op events.
+        #
+        # General usage should not require interacting with this method.
+        #
+        # @param ratio [Integer]
+        # @return [FlagBuilder]
+        #
+        def sampling_ratio(ratio)
+          @sampling_ratio = ratio
+          self
+        end
+
+        #
+        # Set the option to exclude this flag from summary events. This is used to control the size of the summary event
+        # in the event certain flag payloads are large.
+        #
+        # General usage should not require interacting with this method.
+        #
+        # @param exclude [Boolean]
+        # @return [FlagBuilder]
+        #
+        def exclude_from_summaries(exclude)
+          @exclude_from_summaries = exclude
+          self
+        end
+
         #
         # Specifies the fallthrough variation. The fallthrough is the value
         # that is returned if targeting is on and the context was not matched by a more specific
@@ -128,11 +169,6 @@ module LaunchDarkly
           end
         end
 
-        #
-        # @deprecated Backwards compatibility alias for #variation_for_all
-        #
-        alias_method :variation_for_all_users, :variation_for_all
-
         #
         # Sets the flag to always return the specified variation value for all context.
         #
@@ -148,11 +184,6 @@ module LaunchDarkly
           variations(value).variation_for_all(0)
         end
 
-        #
-        # @deprecated Backwards compatibility alias for #value_for_all
-        #
-        alias_method :value_for_all_users, :value_for_all
-
         #
         # Sets the flag to return the specified variation for a specific context key when targeting
         # is on.
@@ -315,11 +346,6 @@ module LaunchDarkly
           self
         end
 
-        #
-        # @deprecated Backwards compatibility alias for #clear_targets
-        #
-        alias_method :clear_user_targets, :clear_targets
-
         #
         # Removes any existing rules from the flag.
         # This undoes the effect of methods like {#if_match}
@@ -376,6 +402,18 @@ module LaunchDarkly
             res[:fallthrough] = { variation: @fallthrough_variation }
           end
 
+          unless @migration_settings.nil?
+            res[:migration] = @migration_settings
+          end
+
+          unless @sampling_ratio.nil? || @sampling_ratio == 1
+            res[:samplingRatio] = @sampling_ratio
+          end
+
+          unless @exclude_from_summaries.nil? || !@exclude_from_summaries
+            res[:excludeFromSummaries] = @exclude_from_summaries
+          end
+
           unless @targets.nil?
             targets = []
             context_targets = []
@@ -403,6 +441,37 @@ module LaunchDarkly
           res
         end
 
+        #
+        # A builder for feature flag migration settings to be used with {FlagBuilder}.
+        #
+        # In the LaunchDarkly model, a flag can be a standard feature flag, or it can be a migration-related flag, in
+        # which case it has migration-specified related settings. These settings control things like the rate at which
+        # reads are tested for consistency between origins.
+        #
+        class FlagMigrationSettingsBuilder
+          def initialize()
+            @check_ratio = nil
+          end
+
+          #
+          # @param ratio [Integer]
+          # @return [FlagMigrationSettingsBuilder]
+          #
+          def check_ratio(ratio)
+            return unless ratio.is_a? Integer
+            @check_ratio = ratio
+            self
+          end
+
+          def build
+            return nil if @check_ratio.nil? || @check_ratio == 1
+
+            {
+              "checkRatio": @check_ratio,
+            }
+          end
+        end
+
         #
         # A builder for feature flag rules to be used with {FlagBuilder}.
         #

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)