launchdarkly-server-sdk 7.0.4 → 7.2.0

data/lib/ldclient-rb/ldclient.rb

@@ -1,6 +1,10 @@
 require "ldclient-rb/impl/big_segments"
+require "ldclient-rb/impl/broadcaster"
+require "ldclient-rb/impl/data_source"
+require "ldclient-rb/impl/data_store"
 require "ldclient-rb/impl/diagnostic_events"
 require "ldclient-rb/impl/evaluator"
+require "ldclient-rb/impl/flag_tracker"
 require "ldclient-rb/impl/store_client_wrapper"
 require "concurrent/atomics"
 require "digest/sha1"
@@ -45,15 +49,22 @@ module LaunchDarkly
 
       @sdk_key = sdk_key
 
+      @shared_executor = Concurrent::SingleThreadExecutor.new
+
+      data_store_broadcaster = LaunchDarkly::Impl::Broadcaster.new(@shared_executor, config.logger)
+      store_sink = LaunchDarkly::Impl::DataStore::UpdateSink.new(data_store_broadcaster)
+
       # We need to wrap the feature store object with a FeatureStoreClientWrapper in order to add
       # some necessary logic around updates. Unfortunately, we have code elsewhere that accesses
       # the feature store through the Config object, so we need to make a new Config that uses
       # the wrapped store.
-      @store = Impl::FeatureStoreClientWrapper.new(config.feature_store)
+      @store = Impl::FeatureStoreClientWrapper.new(config.feature_store, store_sink, config.logger)
       updated_config = config.clone
       updated_config.instance_variable_set(:@feature_store, @store)
       @config = updated_config
 
+      @data_store_status_provider = LaunchDarkly::Impl::DataStore::StatusProvider.new(@store, store_sink)
+
       @big_segment_store_manager = Impl::BigSegmentStoreManager.new(config.big_segments, @config.logger)
       @big_segment_store_status_provider = @big_segment_store_manager.status_provider
 
@@ -79,6 +90,16 @@ module LaunchDarkly
         return  # requestor and update processor are not used in this mode
       end
 
+      flag_tracker_broadcaster = LaunchDarkly::Impl::Broadcaster.new(@shared_executor, @config.logger)
+      @flag_tracker = LaunchDarkly::Impl::FlagTracker.new(flag_tracker_broadcaster, lambda { |key, context| variation(key, context, nil) })
+
+      data_source_broadcaster = LaunchDarkly::Impl::Broadcaster.new(@shared_executor, @config.logger)
+
+      # Make the update sink available on the config so that our data source factory can access the sink with a shared executor.
+      @config.data_source_update_sink = LaunchDarkly::Impl::DataSource::UpdateSink.new(@store, data_source_broadcaster, flag_tracker_broadcaster)
+
+      @data_source_status_provider = LaunchDarkly::Impl::DataSource::StatusProvider.new(data_source_broadcaster, @config.data_source_update_sink)
+
       data_source_or_factory = @config.data_source || self.method(:create_default_data_source)
       if data_source_or_factory.respond_to? :call
         # Currently, data source factories take two parameters unless they need to be aware of diagnostic_accumulator, in
@@ -345,16 +366,53 @@ module LaunchDarkly
       @event_processor.stop
       @big_segment_store_manager.stop
       @store.stop
+      @shared_executor.shutdown
     end
 
     #
     # Returns an interface for tracking the status of a Big Segment store.
     #
-    # The {BigSegmentStoreStatusProvider} has methods for checking whether the Big Segment store
+    # The {Interfaces::BigSegmentStoreStatusProvider} has methods for checking whether the Big Segment store
     # is (as far as the SDK knows) currently operational and tracking changes in this status.
     #
     attr_reader :big_segment_store_status_provider
 
+    #
+    # Returns an interface for tracking the status of a persistent data store.
+    #
+    # The {LaunchDarkly::Interfaces::DataStore::StatusProvider} has methods for
+    # checking whether the data store is (as far as the SDK knows) currently
+    # operational, tracking changes in this status, and getting cache
+    # statistics. These are only relevant for a persistent data store; if you
+    # are using an in-memory data store, then this method will return a stub
+    # object that provides no information.
+    #
+    # @return [LaunchDarkly::Interfaces::DataStore::StatusProvider]
+    #
+    attr_reader :data_store_status_provider
+
+    #
+    # Returns an interface for tracking the status of the data source.
+    #
+    # The data source is the mechanism that the SDK uses to get feature flag
+    # configurations, such as a streaming connection (the default) or poll
+    # requests. The {LaunchDarkly::Interfaces::DataSource::StatusProvider} has
+    # methods for checking whether the data source is (as far as the SDK knows)
+    # currently operational and tracking changes in this status.
+    #
+    # @return [LaunchDarkly::Interfaces::DataSource::StatusProvider]
+    #
+    attr_reader :data_source_status_provider
+
+    #
+    # Returns an interface for tracking changes in feature flag configurations.
+    #
+    # The {LaunchDarkly::Interfaces::FlagTracker} contains methods for
+    # requesting notifications about feature flag changes using an event
+    # listener model.
+    #
+    attr_reader :flag_tracker
+
     private
 
     def create_default_data_source(sdk_key, config, diagnostic_accumulator)
@@ -403,7 +461,11 @@ module LaunchDarkly
         end
       end
 
-      feature = @store.get(FEATURES, key)
+      begin
+        feature = @store.get(FEATURES, key)
+      rescue
+        # Ignored
+      end
 
       if feature.nil?
         @config.logger.info { "[LDClient] Unknown feature flag \"#{key}\". Returning default value" }

data/lib/ldclient-rb/polling.rb

@@ -1,6 +1,7 @@
 require "ldclient-rb/impl/repeating_task"
 
 require "concurrent/atomics"
+require "json"
 require "thread"
 
 module LaunchDarkly
@@ -27,30 +28,75 @@ module LaunchDarkly
     end
 
     def stop
-      @task.stop
-      @config.logger.info { "[LDClient] Polling connection stopped" }
+      stop_with_error_info
     end
 
     def poll
       begin
         all_data = @requestor.request_all_data
         if all_data
-          @config.feature_store.init(all_data)
+          update_sink_or_data_store.init(all_data)
           if @initialized.make_true
             @config.logger.info { "[LDClient] Polling connection initialized" }
             @ready.set
           end
         end
+        @config.data_source_update_sink&.update_status(LaunchDarkly::Interfaces::DataSource::Status::VALID, nil)
+      rescue JSON::ParserError => e
+        @config.logger.error { "[LDClient] JSON parsing failed for polling response." }
+        error_info = LaunchDarkly::Interfaces::DataSource::ErrorInfo.new(
+          LaunchDarkly::Interfaces::DataSource::ErrorInfo::INVALID_DATA,
+          0,
+          e.to_s,
+          Time.now
+        )
+        @config.data_source_update_sink&.update_status(LaunchDarkly::Interfaces::DataSource::Status::INTERRUPTED, error_info)
       rescue UnexpectedResponseError => e
+        error_info = LaunchDarkly::Interfaces::DataSource::ErrorInfo.new(
+          LaunchDarkly::Interfaces::DataSource::ErrorInfo::ERROR_RESPONSE, e.status, nil, Time.now)
         message = Util.http_error_message(e.status, "polling request", "will retry")
         @config.logger.error { "[LDClient] #{message}" }
-        unless Util.http_error_recoverable?(e.status)
+
+        if Util.http_error_recoverable?(e.status)
+          @config.data_source_update_sink&.update_status(
+            LaunchDarkly::Interfaces::DataSource::Status::INTERRUPTED,
+            error_info
+          )
+        else
           @ready.set  # if client was waiting on us, make it stop waiting - has no effect if already set
-          stop
+          stop_with_error_info error_info
         end
       rescue StandardError => e
         Util.log_exception(@config.logger, "Exception while polling", e)
+        @config.data_source_update_sink&.update_status(
+          LaunchDarkly::Interfaces::DataSource::Status::INTERRUPTED,
+          LaunchDarkly::Interfaces::DataSource::ErrorInfo.new(LaunchDarkly::Interfaces::DataSource::ErrorInfo::UNKNOWN, 0, e.to_s, Time.now)
+        )
       end
     end
+
+    #
+    # The original implementation of this class relied on the feature store
+    # directly, which we are trying to move away from. Customers who might have
+    # instantiated this directly for some reason wouldn't know they have to set
+    # the config's sink manually, so we have to fall back to the store if the
+    # sink isn't present.
+    #
+    # The next major release should be able to simplify this structure and
+    # remove the need for fall back to the data store because the update sink
+    # should always be present.
+    #
+    private def update_sink_or_data_store
+      @config.data_source_update_sink || @config.feature_store
+    end
+
+    #
+    # @param [LaunchDarkly::Interfaces::DataSource::ErrorInfo, nil] error_info
+    #
+    private def stop_with_error_info(error_info = nil)
+      @task.stop
+      @config.logger.info { "[LDClient] Polling connection stopped" }
+      @config.data_source_update_sink&.update_status(LaunchDarkly::Interfaces::DataSource::Status::OFF, error_info)
+    end
   end
 end

data/lib/ldclient-rb/requestor.rb

@@ -43,12 +43,10 @@ module LaunchDarkly
 
     private
 
-    def request_single_item(kind, path)
-      Impl::Model.deserialize(kind, make_request(path), @config.logger)
-    end
-
     def make_request(path)
-      uri = URI(@config.base_uri + path)
+      uri = URI(
+        Util.add_payload_filter_key(@config.base_uri + path, @config)
+      )
       headers = {}
       Impl::Util.default_http_headers(@sdk_key, @config).each { |k, v| headers[k] = v }
       headers["Connection"] = "keep-alive"

data/lib/ldclient-rb/stream.rb

@@ -25,6 +25,7 @@ module LaunchDarkly
     def initialize(sdk_key, config, diagnostic_accumulator = nil)
       @sdk_key = sdk_key
       @config = config
+      @data_source_update_sink = config.data_source_update_sink
       @feature_store = config.feature_store
       @initialized = Concurrent::AtomicBoolean.new(false)
       @started = Concurrent::AtomicBoolean.new(false)
@@ -51,19 +52,40 @@ module LaunchDarkly
         reconnect_time: @config.initial_reconnect_delay,
       }
       log_connection_started
-      @es = SSE::Client.new(@config.stream_uri + "/all", **opts) do |conn|
+
+      uri = Util.add_payload_filter_key(@config.stream_uri + "/all", @config)
+      @es = SSE::Client.new(uri, **opts) do |conn|
         conn.on_event { |event| process_message(event) }
         conn.on_error { |err|
           log_connection_result(false)
           case err
           when SSE::Errors::HTTPStatusError
             status = err.status
+            error_info = LaunchDarkly::Interfaces::DataSource::ErrorInfo.new(
+              LaunchDarkly::Interfaces::DataSource::ErrorInfo::ERROR_RESPONSE, status, nil, Time.now)
             message = Util.http_error_message(status, "streaming connection", "will retry")
             @config.logger.error { "[LDClient] #{message}" }
-            unless Util.http_error_recoverable?(status)
+
+            if Util.http_error_recoverable?(status)
+              @data_source_update_sink&.update_status(
+                LaunchDarkly::Interfaces::DataSource::Status::INTERRUPTED,
+                error_info
+              )
+            else
               @ready.set  # if client was waiting on us, make it stop waiting - has no effect if already set
-              stop
+              stop_with_error_info error_info
             end
+          when SSE::Errors::HTTPContentTypeError, SSE::Errors::HTTPProxyError, SSE::Errors::ReadTimeoutError
+            @data_source_update_sink&.update_status(
+              LaunchDarkly::Interfaces::DataSource::Status::INTERRUPTED,
+              LaunchDarkly::Interfaces::DataSource::ErrorInfo.new(LaunchDarkly::Interfaces::DataSource::ErrorInfo::NETWORK_ERROR, 0, err.to_s, Time.now)
+            )
+
+          else
+            @data_source_update_sink&.update_status(
+              LaunchDarkly::Interfaces::DataSource::Status::INTERRUPTED,
+              LaunchDarkly::Interfaces::DataSource::ErrorInfo.new(LaunchDarkly::Interfaces::DataSource::ErrorInfo::UNKNOWN, 0, err.to_s, Time.now)
+            )
           end
         }
       end
@@ -72,46 +94,86 @@ module LaunchDarkly
     end
 
     def stop
+      stop_with_error_info
+    end
+
+    private
+
+    #
+    # @param [LaunchDarkly::Interfaces::DataSource::ErrorInfo, nil] error_info
+    #
+    def stop_with_error_info(error_info = nil)
       if @stopped.make_true
         @es.close
+        @data_source_update_sink&.update_status(LaunchDarkly::Interfaces::DataSource::Status::OFF, error_info)
         @config.logger.info { "[LDClient] Stream connection stopped" }
       end
     end
 
-    private
+    #
+    # The original implementation of this class relied on the feature store
+    # directly, which we are trying to move away from. Customers who might have
+    # instantiated this directly for some reason wouldn't know they have to set
+    # the config's sink manually, so we have to fall back to the store if the
+    # sink isn't present.
+    #
+    # The next major release should be able to simplify this structure and
+    # remove the need for fall back to the data store because the update sink
+    # should always be present.
+    #
+    def update_sink_or_data_store
+      @data_source_update_sink || @feature_store
+    end
 
     def process_message(message)
       log_connection_result(true)
       method = message.type
       @config.logger.debug { "[LDClient] Stream received #{method} message: #{message.data}" }
-      if method == PUT
-        message = JSON.parse(message.data, symbolize_names: true)
-        all_data = Impl::Model.make_all_store_data(message[:data], @config.logger)
-        @feature_store.init(all_data)
-        @initialized.make_true
-        @config.logger.info { "[LDClient] Stream initialized" }
-        @ready.set
-      elsif method == PATCH
-        data = JSON.parse(message.data, symbolize_names: true)
-        for kind in [FEATURES, SEGMENTS]
-          key = key_for_path(kind, data[:path])
-          if key
-            item = Impl::Model.deserialize(kind, data[:data], @config.logger)
-            @feature_store.upsert(kind, item)
-            break
+
+      begin
+        if method == PUT
+          message = JSON.parse(message.data, symbolize_names: true)
+          all_data = Impl::Model.make_all_store_data(message[:data], @config.logger)
+          update_sink_or_data_store.init(all_data)
+          @initialized.make_true
+          @config.logger.info { "[LDClient] Stream initialized" }
+          @ready.set
+        elsif method == PATCH
+          data = JSON.parse(message.data, symbolize_names: true)
+          for kind in [FEATURES, SEGMENTS]
+            key = key_for_path(kind, data[:path])
+            if key
+              item = Impl::Model.deserialize(kind, data[:data], @config.logger)
+              update_sink_or_data_store.upsert(kind, item)
+              break
+            end
           end
-        end
-      elsif method == DELETE
-        data = JSON.parse(message.data, symbolize_names: true)
-        for kind in [FEATURES, SEGMENTS]
-          key = key_for_path(kind, data[:path])
-          if key
-            @feature_store.delete(kind, key, data[:version])
-            break
+        elsif method == DELETE
+          data = JSON.parse(message.data, symbolize_names: true)
+          for kind in [FEATURES, SEGMENTS]
+            key = key_for_path(kind, data[:path])
+            if key
+              update_sink_or_data_store.delete(kind, key, data[:version])
+              break
+            end
           end
+        else
+          @config.logger.warn { "[LDClient] Unknown message received: #{method}" }
         end
-      else
-        @config.logger.warn { "[LDClient] Unknown message received: #{method}" }
+
+        @data_source_update_sink&.update_status(LaunchDarkly::Interfaces::DataSource::Status::VALID, nil)
+      rescue JSON::ParserError => e
+        @config.logger.error { "[LDClient] JSON parsing failed for method #{method}. Ignoring event." }
+        error_info = LaunchDarkly::Interfaces::DataSource::ErrorInfo.new(
+          LaunchDarkly::Interfaces::DataSource::ErrorInfo::INVALID_DATA,
+          0,
+          e.to_s,
+          Time.now
+        )
+        @data_source_update_sink&.update_status(LaunchDarkly::Interfaces::DataSource::Status::INTERRUPTED, error_info)
+
+        # Re-raise the exception so the SSE implementation can catch it and restart the stream.
+        raise
       end
     end
 

data/lib/ldclient-rb/util.rb

@@ -4,6 +4,32 @@ require "http"
 module LaunchDarkly
   # @private
   module Util
+    #
+    # Append the payload filter key query parameter to the provided URI.
+    #
+    # @param uri [String]
+    # @param config [Config]
+    # @return [String]
+    #
+    def self.add_payload_filter_key(uri, config)
+      return uri if config.payload_filter_key.nil?
+
+      unless config.payload_filter_key.is_a?(String) && !config.payload_filter_key.empty?
+        config.logger.warn { "[LDClient] Filter key must be a non-empty string. No filtering will be applied." }
+        return uri
+      end
+
+      begin
+        parsed = URI.parse(uri)
+        new_query_params = URI.decode_www_form(String(parsed.query)) << ["filter", config.payload_filter_key]
+        parsed.query = URI.encode_www_form(new_query_params)
+        parsed.to_s
+      rescue URI::InvalidURIError
+        config.logger.warn { "[LDClient] URI could not be parsed. No filtering will be applied." }
+        uri
+      end
+    end
+
     def self.new_http_client(uri_s, config)
       http_client_options = {}
       if config.socket_factory

data/lib/ldclient-rb/version.rb

@@ -1,3 +1,3 @@
 module LaunchDarkly
-  VERSION = "7.0.4"
+  VERSION = "7.2.0"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: launchdarkly-server-sdk
 version: !ruby/object:Gem::Version
-  version: 7.0.4
+  version: 7.2.0
 platform: ruby
 authors:
 - LaunchDarkly
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2023-04-03 00:00:00.000000000 Z
+date: 2023-05-04 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: aws-sdk-dynamodb
@@ -38,6 +38,20 @@ dependencies:
     - - '='
       - !ruby/object:Gem::Version
         version: 2.2.33
+- !ruby/object:Gem::Dependency
+  name: simplecov
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.21'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.21'
 - !ruby/object:Gem::Dependency
   name: rspec
   requirement: !ruby/object:Gem::Requirement
@@ -274,8 +288,12 @@ files:
 - lib/ldclient-rb/flags_state.rb
 - lib/ldclient-rb/impl.rb
 - lib/ldclient-rb/impl/big_segments.rb
+- lib/ldclient-rb/impl/broadcaster.rb
 - lib/ldclient-rb/impl/context.rb
 - lib/ldclient-rb/impl/context_filter.rb
+- lib/ldclient-rb/impl/data_source.rb
+- lib/ldclient-rb/impl/data_store.rb
+- lib/ldclient-rb/impl/dependency_tracker.rb
 - lib/ldclient-rb/impl/diagnostic_events.rb
 - lib/ldclient-rb/impl/evaluator.rb
 - lib/ldclient-rb/impl/evaluator_bucketing.rb
@@ -284,6 +302,7 @@ files:
 - lib/ldclient-rb/impl/event_sender.rb
 - lib/ldclient-rb/impl/event_summarizer.rb
 - lib/ldclient-rb/impl/event_types.rb
+- lib/ldclient-rb/impl/flag_tracker.rb
 - lib/ldclient-rb/impl/integrations/consul_impl.rb
 - lib/ldclient-rb/impl/integrations/dynamodb_impl.rb
 - lib/ldclient-rb/impl/integrations/file_data_source.rb
@@ -338,7 +357,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.4.10
+rubygems_version: 3.4.12
 signing_key: 
 specification_version: 4
 summary: LaunchDarkly SDK for Ruby