prepare 7.2.0 release

.circleci/config.yml

@@ -30,6 +30,10 @@ jobs:
   build-test-windows:
     executor: win/default
 
+    environment:
+      LD_SKIP_DATABASE_TESTS: 0
+      LD_ENABLE_CODE_COVERAGE: 1
+
     steps:
       - checkout
 
@@ -79,6 +83,7 @@ jobs:
       - run: bundle _2.2.33_ install
       - run: mkdir /tmp/circle-artifacts
       - run: bundle _2.2.33_ exec rspec --format documentation --format RspecJunitFormatter -o /tmp/circle-artifacts/rspec.xml spec
+      - run: mv coverage /tmp/circle-artifacts/
 
       - store_test_results:
           path: /tmp/circle-artifacts
@@ -99,6 +104,10 @@ jobs:
       - image: redis
       - image: amazon/dynamodb-local
 
+    environment:
+      LD_SKIP_DATABASE_TESTS: 0
+      LD_ENABLE_CODE_COVERAGE: 1
+
     steps:
       - checkout
       - when:
@@ -116,6 +125,7 @@ jobs:
       - run: bundle _2.2.33_ install
       - run: mkdir /tmp/circle-artifacts
       - run: bundle _2.2.33_ exec rspec --format documentation --format RspecJunitFormatter -o /tmp/circle-artifacts/rspec.xml spec
+      - run: mv coverage /tmp/circle-artifacts/
 
       - when:
           condition:

.ldrelease/config.yml

@@ -20,8 +20,6 @@ jobs:
       image: ruby:2.7-buster
     template:
       name: ruby
-    env:
-      LD_SKIP_DATABASE_TESTS: "1"  # Don't run Redis/Consul/DynamoDB tests in release; they are run in CI
 
 documentation:
   gitHubPages: true

CONTRIBUTING.md

@@ -30,7 +30,7 @@ To run all unit tests:
 bundle exec rspec spec
 ```
 
-By default, the full unit test suite includes live tests of the integrations for Consul, DynamoDB, and Redis. Those tests expect you to have instances of all of those databases running locally. To skip them, set the environment variable `LD_SKIP_DATABASE_TESTS=1` before running the tests.
+The full unit test suite includes live tests of the integrations for Consul, DynamoDB, and Redis. Those tests expect you to have instances of all of those databases running locally. By default, these tests will be skipped. To run them, set the environment variable `LD_SKIP_DATABASE_TESTS=0` before running the tests.
 
 ### Building documentation
 

launchdarkly-server-sdk.gemspec

@@ -23,6 +23,7 @@ Gem::Specification.new do |spec|
 
   spec.add_development_dependency "aws-sdk-dynamodb", "~> 1.57"
   spec.add_development_dependency "bundler", "2.2.33"
+  spec.add_development_dependency "simplecov", "~> 0.21"
   spec.add_development_dependency "rspec", "~> 3.10"
   spec.add_development_dependency "diplomat", "~> 2.6"
   spec.add_development_dependency "redis", "~> 5.0"

lib/ldclient-rb/config.rb

@@ -90,8 +90,23 @@ def initialize(opts = {})
       @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.

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

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