launchdarkly-server-sdk 7.1.0 → 7.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 4c7c60035c46d6e2284ad78f0f4e33637f804faf9c90229e09b9d7c5b64c3bf8
-  data.tar.gz: 38f330a730ce6459d7a50bf0afec0db47462afafa7f927f09a2978ae3bd1cf18
+  metadata.gz: 0b14010cc3e61f33c32a83dc937046b23bdd00eabe728cef7a139e4300810cf0
+  data.tar.gz: 21eaf262fe3279bd8d4db2169737d3d934d0471e308b97037473e8d84d81af51
 SHA512:
-  metadata.gz: c15f778108d9fdc2d47b51846d068e553be322d4e072498368d9c8cc7161f2e15c8977ccc5dcf8e565a707d727029901bbd6e0a7780bb42c0407f21cbef959ec
-  data.tar.gz: c7eca9b4edb6c458b1a034161ca9adaac955d81155308c23f913c434cf02a6479e15a7df35ea9ae4cf4d5e21b288c485a3ef1c380f90d6e4581e8993a7bc1e37
+  metadata.gz: b59b63876011041a2f37b2bcfabd179318622b1daadb7a33c5eaa217efb68abc2d2cc3d224c7ff6ad1e7a6b8223b15844a318cee767612d155b5b29a6cc135e8
+  data.tar.gz: 6808eb4a6eca0d7680152022344a8aee930b864282a37e12da806b8d311fb9d6cbaac86fef2732e3abbaa75f025c3e67edfab7869d2b117e9a82b14f32f98b39

data/lib/ldclient-rb/config.rb

@@ -90,8 +90,23 @@ module LaunchDarkly
       @big_segments = opts[:big_segments] || BigSegmentsConfig.new(store: nil)
       @application = LaunchDarkly::Impl::Util.validate_application_info(opts[:application] || {}, @logger)
       @payload_filter_key = opts[:payload_filter_key]
+      @data_source_update_sink = nil
     end
 
+    #
+    # Returns the component that allows a data source to push data into the SDK.
+    #
+    # This property should only be set by the SDK. Long term access of this
+    # property is not supported; it is temporarily being exposed to maintain
+    # backwards compatibility while the SDK structure is updated.
+    #
+    # Custom data source implementations should integrate with this sink if
+    # they want to provide support for data source status listeners.
+    #
+    # @private
+    #
+    attr_accessor :data_source_update_sink
+
     #
     # The base URL for the LaunchDarkly server. This is configurable mainly for testing
     # purposes; most users should use the default value.

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

@@ -0,0 +1,78 @@
+# frozen_string_literal: true
+
+module LaunchDarkly
+  module Impl
+
+    #
+    # A generic mechanism for registering event listeners and broadcasting
+    # events to them.
+    #
+    # The SDK maintains an instance of this for each available type of listener
+    # (flag change, data store status, etc.). They are all intended to share a
+    # single executor service; notifications are submitted individually to this
+    # service for each listener.
+    #
+    class Broadcaster
+      def initialize(executor, logger)
+        @listeners = Concurrent::Set.new
+        @executor = executor
+        @logger = logger
+      end
+
+      #
+      # Register a listener to this broadcaster.
+      #
+      # @param listener [#update]
+      #
+      def add_listener(listener)
+        unless listener.respond_to? :update
+          logger.warn("listener (#{listener.class}) does not respond to :update method. ignoring as registered listener")
+          return
+        end
+
+        listeners.add(listener)
+      end
+
+      #
+      # Removes a registered listener from this broadcaster.
+      #
+      def remove_listener(listener)
+        listeners.delete(listener)
+      end
+
+      def has_listeners?
+        !listeners.empty?
+      end
+
+      #
+      # Broadcast the provided event to all registered listeners.
+      #
+      # Each listener will be notified using the broadcasters executor. This
+      # method is non-blocking.
+      #
+      def broadcast(event)
+        listeners.each do |listener|
+          executor.post do
+            begin
+              listener.update(event)
+            rescue StandardError => e
+              logger.error("listener (#{listener.class}) raised exception (#{e}) processing event (#{event.class})")
+            end
+          end
+        end
+      end
+
+
+      private
+
+      # @return [Concurrent::ThreadPoolExecutor]
+      attr_reader :executor
+
+      # @return [Logger]
+      attr_reader :logger
+
+      # @return [Concurrent::Set]
+      attr_reader :listeners
+    end
+  end
+end

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

@@ -0,0 +1,188 @@
+require "concurrent"
+require "forwardable"
+require "ldclient-rb/impl/dependency_tracker"
+require "ldclient-rb/interfaces"
+require "set"
+
+module LaunchDarkly
+  module Impl
+    module DataSource
+      class StatusProvider
+        include LaunchDarkly::Interfaces::DataSource::StatusProvider
+
+        extend Forwardable
+        def_delegators :@status_broadcaster, :add_listener, :remove_listener
+
+        def initialize(status_broadcaster, update_sink)
+          # @type [Broadcaster]
+          @status_broadcaster = status_broadcaster
+          # @type [UpdateSink]
+          @data_source_update_sink = update_sink
+        end
+
+        def status
+          @data_source_update_sink.current_status
+        end
+      end
+
+      class UpdateSink
+        include LaunchDarkly::Interfaces::DataSource::UpdateSink
+
+        # @return [LaunchDarkly::Interfaces::DataSource::Status]
+        attr_reader :current_status
+
+        def initialize(data_store, status_broadcaster, flag_change_broadcaster)
+          # @type [LaunchDarkly::Interfaces::FeatureStore]
+          @data_store = data_store
+          # @type [Broadcaster]
+          @status_broadcaster = status_broadcaster
+          # @type [Broadcaster]
+          @flag_change_broadcaster = flag_change_broadcaster
+          @dependency_tracker = LaunchDarkly::Impl::DependencyTracker.new
+
+          @mutex = Mutex.new
+          @current_status = LaunchDarkly::Interfaces::DataSource::Status.new(
+            LaunchDarkly::Interfaces::DataSource::Status::INITIALIZING,
+            Time.now,
+            nil)
+        end
+
+        def init(all_data)
+          old_data = nil
+          monitor_store_update do
+            if @flag_change_broadcaster.has_listeners?
+              old_data = {}
+              LaunchDarkly::ALL_KINDS.each do |kind|
+                old_data[kind] = @data_store.all(kind)
+              end
+            end
+
+            @data_store.init(all_data)
+          end
+
+          update_full_dependency_tracker(all_data)
+
+          return if old_data.nil?
+
+          send_change_events(
+            compute_changed_items_for_full_data_set(old_data, all_data)
+          )
+        end
+
+        def upsert(kind, item)
+          monitor_store_update { @data_store.upsert(kind, item) }
+
+          # TODO(sc-197908): We only want to do this if the store successfully
+          # updates the record.
+          @dependency_tracker.update_dependencies_from(kind, item[:key], item)
+          if @flag_change_broadcaster.has_listeners?
+            affected_items = Set.new
+            @dependency_tracker.add_affected_items(affected_items, {kind: kind, key: item[:key]})
+            send_change_events(affected_items)
+          end
+        end
+
+        def delete(kind, key, version)
+          monitor_store_update { @data_store.delete(kind, key, version) }
+
+          @dependency_tracker.update_dependencies_from(kind, key, nil)
+          if @flag_change_broadcaster.has_listeners?
+            affected_items = Set.new
+            @dependency_tracker.add_affected_items(affected_items, {kind: kind, key: key})
+            send_change_events(affected_items)
+          end
+        end
+
+        def update_status(new_state, new_error)
+          return if new_state.nil?
+
+          status_to_broadcast = nil
+
+          @mutex.synchronize do
+            old_status = @current_status
+
+            if new_state == LaunchDarkly::Interfaces::DataSource::Status::INTERRUPTED && old_status.state == LaunchDarkly::Interfaces::DataSource::Status::INITIALIZING
+              # See {LaunchDarkly::Interfaces::DataSource::UpdateSink#update_status} for more information
+              new_state = LaunchDarkly::Interfaces::DataSource::Status::INITIALIZING
+            end
+
+            unless new_state == old_status.state && new_error.nil?
+              @current_status = LaunchDarkly::Interfaces::DataSource::Status.new(
+                new_state,
+                new_state == current_status.state ? current_status.state_since : Time.now,
+                new_error.nil? ? current_status.last_error : new_error
+              )
+              status_to_broadcast = current_status
+            end
+          end
+
+          @status_broadcaster.broadcast(status_to_broadcast) unless status_to_broadcast.nil?
+        end
+
+        private def update_full_dependency_tracker(all_data)
+          @dependency_tracker.reset
+          all_data.each do |kind, items|
+            items.each do |key, item|
+              @dependency_tracker.update_dependencies_from(kind, item.key, item)
+            end
+          end
+        end
+
+
+        #
+        # Method to monitor updates to the store. You provide a block to update
+        # the store. This mthod wraps that block, catching and re-raising all
+        # errors, and notifying all status listeners of the error.
+        #
+        private def monitor_store_update
+          begin
+            yield
+          rescue => e
+            error_info = LaunchDarkly::Interfaces::DataSource::ErrorInfo.new(LaunchDarkly::Interfaces::DataSource::ErrorInfo::STORE_ERROR, 0, e.to_s, Time.now)
+            update_status(LaunchDarkly::Interfaces::DataSource::Status::INTERRUPTED, error_info)
+            raise
+          end
+        end
+
+
+        #
+        # @param [Hash] old_data
+        # @param [Hash] new_data
+        # @return [Set]
+        #
+        private def compute_changed_items_for_full_data_set(old_data, new_data)
+          affected_items = Set.new
+
+          LaunchDarkly::ALL_KINDS.each do |kind|
+            old_items = old_data[kind] || {}
+            new_items = new_data[kind] || {}
+
+            old_items.keys.concat(new_items.keys).each do |key|
+              old_item = old_items[key]
+              new_item = new_items[key]
+
+              next if old_item.nil? && new_item.nil?
+
+              if old_item.nil? || new_item.nil? || old_item[:version] < new_item[:version]
+                @dependency_tracker.add_affected_items(affected_items, {kind: kind, key: key.to_s})
+              end
+            end
+          end
+
+          affected_items
+        end
+
+        #
+        # @param affected_items [Set]
+        #
+        private def send_change_events(affected_items)
+          affected_items.each do |item|
+            if item[:kind] == LaunchDarkly::FEATURES
+              @flag_change_broadcaster.broadcast(LaunchDarkly::Interfaces::FlagChange.new(item[:key]))
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,59 @@
+require 'concurrent'
+require "ldclient-rb/interfaces"
+
+module LaunchDarkly
+  module Impl
+    module DataStore
+      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
+
+        def initialize(broadcaster)
+          @broadcaster = broadcaster
+          @last_status = Concurrent::AtomicReference.new(
+            LaunchDarkly::Interfaces::DataStore::Status.new(true, false)
+          )
+        end
+
+        def update_status(status)
+          return if status.nil?
+
+          old_status = @last_status.get_and_set(status)
+          @broadcaster.broadcast(status) unless old_status == status
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,102 @@
+module LaunchDarkly
+  module Impl
+    class DependencyTracker
+      def initialize
+        @from = {}
+        @to = {}
+      end
+
+      #
+      # Updates the dependency graph when an item has changed.
+      #
+      # @param from_kind [Object] the changed item's kind
+      # @param from_key [String] the changed item's key
+      # @param from_item [Object] the changed item
+      #
+      def update_dependencies_from(from_kind, from_key, from_item)
+        from_what = { kind: from_kind, key: from_key }
+        updated_dependencies = DependencyTracker.compute_dependencies_from(from_kind, from_item)
+
+        old_dependency_set = @from[from_what]
+        unless old_dependency_set.nil?
+          old_dependency_set.each do |kind_and_key|
+            deps_to_this_old_dep = @to[kind_and_key]
+            deps_to_this_old_dep&.delete(from_what)
+          end
+        end
+
+        @from[from_what] = updated_dependencies
+        updated_dependencies.each do |kind_and_key|
+          deps_to_this_new_dep = @to[kind_and_key]
+          if deps_to_this_new_dep.nil?
+            deps_to_this_new_dep = Set.new
+            @to[kind_and_key] = deps_to_this_new_dep
+          end
+          deps_to_this_new_dep.add(from_what)
+        end
+      end
+
+      def self.segment_keys_from_clauses(clauses)
+        clauses.flat_map do |clause|
+          if clause.op == :segmentMatch
+            clause.values.map { |value| {kind: LaunchDarkly::SEGMENTS, key: value }}
+          else
+            []
+          end
+        end
+      end
+
+      #
+      # @param from_kind [String]
+      # @param from_item [LaunchDarkly::Impl::Model::FeatureFlag, LaunchDarkly::Impl::Model::Segment]
+      # @return [Set]
+      #
+      def self.compute_dependencies_from(from_kind, from_item)
+        return Set.new if from_item.nil?
+
+        if from_kind == LaunchDarkly::FEATURES
+          prereq_keys = from_item.prerequisites.map { |prereq| {kind: from_kind, key: prereq.key} }
+          segment_keys = from_item.rules.flat_map { |rule| DependencyTracker.segment_keys_from_clauses(rule.clauses) }
+
+          results = Set.new(prereq_keys)
+          results.merge(segment_keys)
+        elsif from_kind == LaunchDarkly::SEGMENTS
+          kind_and_keys  = from_item.rules.flat_map do |rule|
+            DependencyTracker.segment_keys_from_clauses(rule.clauses)
+          end
+          Set.new(kind_and_keys)
+        else
+          Set.new
+        end
+      end
+
+      #
+      # Clear any tracked dependencies and reset the tracking state to a clean slate.
+      #
+      def reset
+        @from.clear
+        @to.clear
+      end
+
+      #
+      # Populates the given set with the union of the initial item and all items that directly or indirectly
+      # depend on it (based on the current state of the dependency graph).
+      #
+      # @param items_out [Set]
+      # @param initial_modified_item [Object]
+      #
+      def add_affected_items(items_out, initial_modified_item)
+        return if items_out.include? initial_modified_item
+
+        items_out.add(initial_modified_item)
+        affected_items = @to[initial_modified_item]
+
+        return if affected_items.nil?
+
+        affected_items.each do |affected_item|
+          add_affected_items(items_out, affected_item)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,58 @@
+require "concurrent"
+require "ldclient-rb/interfaces"
+require "forwardable"
+
+module LaunchDarkly
+  module Impl
+    class FlagTracker
+      include LaunchDarkly::Interfaces::FlagTracker
+
+      extend Forwardable
+      def_delegators :@broadcaster, :add_listener, :remove_listener
+
+      def initialize(broadcaster, eval_fn)
+        @broadcaster = broadcaster
+        @eval_fn = eval_fn
+      end
+
+      def add_flag_value_change_listener(key, context, listener)
+        flag_change_listener = FlagValueChangeAdapter.new(key, context, listener, @eval_fn)
+        add_listener(flag_change_listener)
+
+        flag_change_listener
+      end
+
+      #
+      # An adapter which turns a normal flag change listener into a flag value change listener.
+      #
+      class FlagValueChangeAdapter
+        # @param [Symbol] flag_key
+        # @param [LaunchDarkly::LDContext] context
+        # @param [#update] listener
+        # @param [#call] eval_fn
+        def initialize(flag_key, context, listener, eval_fn)
+          @flag_key = flag_key
+          @context = context
+          @listener = listener
+          @eval_fn = eval_fn
+          @value = Concurrent::AtomicReference.new(@eval_fn.call(@flag_key, @context))
+        end
+
+        #
+        # @param [LaunchDarkly::Interfaces::FlagChange] flag_change
+        #
+        def update(flag_change)
+          return unless flag_change.key == @flag_key
+
+          new_eval = @eval_fn.call(@flag_key, @context)
+          old_eval = @value.get_and_set(new_eval)
+
+          return if new_eval == old_eval
+
+          @listener.update(
+            LaunchDarkly::Interfaces::FlagValueChange.new(@flag_key, old_eval, new_eval))
+        end
+      end
+    end
+  end
+end

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

@@ -119,6 +119,18 @@ module LaunchDarkly
             end
           end
 
+          def available?
+            # Most implementations use the initialized_internal? method as a
+            # proxy for this check. However, since `initialized_internal?`
+            # catches a KeyNotFound exception, and that exception can be raised
+            # when the server goes away, we have to modify our behavior
+            # slightly.
+            Diplomat::Kv.get(inited_key, {}, :return, :return)
+            true
+          rescue
+            false
+          end
+
           def stop
             # There's no Consul client instance to dispose of
           end

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

@@ -62,6 +62,14 @@ module LaunchDarkly
             "DynamoDBFeatureStore"
           end
 
+          def available?
+            resp = get_item_by_keys(inited_key, inited_key)
+            !resp.item.nil? && resp.item.length > 0
+            true
+          rescue
+            false
+          end
+
           def init_internal(all_data)
             # Start by reading the existing keys; we will later delete any of these that weren't in all_data.
             unused_old_keys = read_existing_keys(all_data.keys)

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

@@ -20,8 +20,15 @@ module LaunchDarkly
         rescue LoadError
         end
 
-        def initialize(feature_store, logger, options={})
-          @feature_store = feature_store
+        #
+        # @param data_store [LaunchDarkly::Interfaces::FeatureStore]
+        # @param data_source_update_sink [LaunchDarkly::Interfaces::DataSource::UpdateSink, nil] Might be nil for backwards compatibility reasons.
+        # @param logger [Logger]
+        # @param options [Hash]
+        #
+        def initialize(data_store, data_source_update_sink, logger, options={})
+          @data_store = data_source_update_sink || data_store
+          @data_source_update_sink = data_source_update_sink
           @logger = logger
           @paths = options[:paths] || []
           if @paths.is_a? String
@@ -80,10 +87,15 @@ module LaunchDarkly
               load_file(path, all_data)
             rescue => exn
               LaunchDarkly::Util.log_exception(@logger, "Unable to load flag data from \"#{path}\"", exn)
+              @data_source_update_sink&.update_status(
+                LaunchDarkly::Interfaces::DataSource::Status::INTERRUPTED,
+                LaunchDarkly::Interfaces::DataSource::ErrorInfo.new(LaunchDarkly::Interfaces::DataSource::ErrorInfo::INVALID_DATA, 0, exn.to_s, Time.now)
+              )
               return
             end
           end
-          @feature_store.init(all_data)
+          @data_store.init(all_data)
+          @data_source_update_sink&.update_status(LaunchDarkly::Interfaces::DataSource::Status::VALID, nil)
           @initialized.make_true
         end
 

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

@@ -42,6 +42,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.
@@ -154,6 +162,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