launchdarkly-server-sdk 8.11.2-java → 8.12.0-java

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

@@ -0,0 +1,108 @@
+require "ldclient-rb/impl/repeating_task"
+require "ldclient-rb/impl/util"
+
+require "concurrent/atomics"
+require "json"
+require "thread"
+
+module LaunchDarkly
+  module Impl
+    module DataSource
+      class PollingProcessor
+        def initialize(config, requestor)
+          @config = config
+          @requestor = requestor
+          @initialized = Concurrent::AtomicBoolean.new(false)
+          @started = Concurrent::AtomicBoolean.new(false)
+          @ready = Concurrent::Event.new
+          @task = Impl::RepeatingTask.new(@config.poll_interval, 0, -> { self.poll }, @config.logger, 'LD/PollingDataSource')
+        end
+
+        def initialized?
+          @initialized.value
+        end
+
+        def start
+          return @ready unless @started.make_true
+          @config.logger.info { "[LDClient] Initializing polling connection" }
+          @task.start
+          @ready
+        end
+
+        def stop
+          stop_with_error_info
+        end
+
+        def poll
+          begin
+            all_data = @requestor.request_all_data
+            if 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 Impl::DataSource::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}" }
+
+            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_with_error_info error_info
+            end
+          rescue StandardError => e
+            Impl::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
+          @requestor.stop if @requestor.respond_to?(: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
+  end
+end
+

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

@@ -0,0 +1,113 @@
+require "ldclient-rb/impl/model/serialization"
+require "ldclient-rb/impl/util"
+require "ldclient-rb/impl/data_system/http_config_options"
+
+require "concurrent/atomics"
+require "json"
+require "uri"
+require "http"
+
+module LaunchDarkly
+  module Impl
+    module DataSource
+      class UnexpectedResponseError < StandardError
+        def initialize(status)
+          @status = status
+          super("HTTP error #{status}")
+        end
+
+        def status
+          @status
+        end
+      end
+
+      class Requestor
+        CacheEntry = Struct.new(:etag, :body)
+
+        def initialize(sdk_key, config)
+          @sdk_key = sdk_key
+          @config = config
+          @http_config = DataSystem::HttpConfigOptions.new(
+            base_uri: config.base_uri,
+            socket_factory: config.socket_factory,
+            read_timeout: config.read_timeout,
+            connect_timeout: config.connect_timeout
+          )
+          @http_client = Impl::Util.new_http_client(@http_config)
+            .use(:auto_inflate)
+            .headers("Accept-Encoding" => "gzip")
+          @cache = @config.cache_store
+        end
+
+        def request_all_data()
+          all_data = JSON.parse(make_request("/sdk/latest-all"), symbolize_names: true)
+          Impl::Model.make_all_store_data(all_data, @config.logger)
+        end
+
+        def stop
+          begin
+            @http_client.close
+          rescue
+          end
+        end
+
+        private
+
+        def make_request(path)
+          uri = URI(
+            Util.add_payload_filter_key(@http_config.base_uri + path, @config)
+          )
+          headers = {}
+          Impl::Util.default_http_headers(@sdk_key, @config).each { |k, v| headers[k] = v }
+          headers["Connection"] = "keep-alive"
+          cached = @cache.read(uri)
+          unless cached.nil?
+            headers["If-None-Match"] = cached.etag
+          end
+          response = @http_client.request("GET", uri, {
+            headers: headers,
+          })
+          status = response.status.code
+          # must fully read body for persistent connections
+          body = response.to_s
+          @config.logger.debug { "[LDClient] Got response from uri: #{uri}\n\tstatus code: #{status}\n\theaders: #{response.headers.to_h}\n\tbody: #{body}" }
+          if status == 304 && !cached.nil?
+            body = cached.body
+          else
+            @cache.delete(uri)
+            if status < 200 || status >= 300
+              raise UnexpectedResponseError.new(status)
+            end
+            body = fix_encoding(body, response.headers["content-type"])
+            etag = response.headers["etag"]
+            @cache.write(uri, CacheEntry.new(etag, body)) unless etag.nil?
+          end
+          body
+        end
+
+        def fix_encoding(body, content_type)
+          return body if content_type.nil?
+          media_type, charset = parse_content_type(content_type)
+          return body if charset.nil?
+          body.force_encoding(Encoding::find(charset)).encode(Encoding::UTF_8)
+        end
+
+        def parse_content_type(value)
+          return [nil, nil] if value.nil? || value == ''
+          parts = value.split(/; */)
+          return [value, nil] if parts.count < 2
+          charset = nil
+          parts.each do |part|
+            fields = part.split('=')
+            if fields.count >= 2 && fields[0] == 'charset'
+              charset = fields[1]
+              break
+            end
+          end
+          [parts[0], charset]
+        end
+      end
+    end
+  end
+end
+

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

@@ -0,0 +1,83 @@
+# frozen_string_literal: true
+
+require "concurrent"
+require "forwardable"
+require "ldclient-rb/interfaces"
+
+module LaunchDarkly
+  module Impl
+    module DataSource
+      #
+      # Provides status tracking and listener management for data sources.
+      #
+      # This class implements the {LaunchDarkly::Interfaces::DataSource::StatusProvider} interface.
+      # It maintains the current status of the data source and broadcasts status changes to listeners.
+      #
+      class StatusProviderV2
+        include LaunchDarkly::Interfaces::DataSource::StatusProvider
+
+        extend Forwardable
+        def_delegators :@status_broadcaster, :add_listener, :remove_listener
+
+        #
+        # Creates a new status provider.
+        #
+        # @param status_broadcaster [LaunchDarkly::Impl::Broadcaster] Broadcaster for status changes
+        #
+        def initialize(status_broadcaster)
+          @status_broadcaster = status_broadcaster
+          @status = LaunchDarkly::Interfaces::DataSource::Status.new(
+            LaunchDarkly::Interfaces::DataSource::Status::INITIALIZING,
+            Time.now,
+            nil
+          )
+          @lock = Concurrent::ReadWriteLock.new
+        end
+
+        # (see LaunchDarkly::Interfaces::DataSource::StatusProvider#status)
+        def status
+          @lock.with_read_lock do
+            @status
+          end
+        end
+
+        # (see LaunchDarkly::Interfaces::DataSource::UpdateSink#update_status)
+        def update_status(new_state, new_error)
+          status_to_broadcast = nil
+
+          @lock.with_write_lock do
+            old_status = @status
+
+            # Special handling: INTERRUPTED during INITIALIZING stays INITIALIZING
+            if new_state == LaunchDarkly::Interfaces::DataSource::Status::INTERRUPTED &&
+                old_status.state == LaunchDarkly::Interfaces::DataSource::Status::INITIALIZING
+              new_state = LaunchDarkly::Interfaces::DataSource::Status::INITIALIZING
+            end
+
+            # Special handling: You can't go back to INITIALIZING after being anything else
+            if new_state == LaunchDarkly::Interfaces::DataSource::Status::INITIALIZING && !old_status.state.nil?
+              new_state = old_status.state
+            end
+
+            # No change if state is the same and no error
+            return if new_state == old_status.state && new_error.nil?
+
+            new_since = new_state == old_status.state ? @status.state_since : Time.now
+            new_error = @status.last_error if new_error.nil?
+
+            @status = LaunchDarkly::Interfaces::DataSource::Status.new(
+              new_state,
+              new_since,
+              new_error
+            )
+
+            status_to_broadcast = @status
+          end
+
+          @status_broadcaster.broadcast(status_to_broadcast) if status_to_broadcast
+        end
+      end
+    end
+  end
+end
+

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

@@ -0,0 +1,198 @@
+require "ldclient-rb/impl/model/serialization"
+require "ldclient-rb/impl/util"
+require "ldclient-rb/in_memory_store"
+
+require "concurrent/atomics"
+require "json"
+require "ld-eventsource"
+
+module LaunchDarkly
+  module Impl
+    module DataSource
+      PUT = :put
+      PATCH = :patch
+      DELETE = :delete
+      READ_TIMEOUT_SECONDS = 300  # 5 minutes; the stream should send a ping every 3 minutes
+
+      KEY_PATHS = {
+        Impl::DataStore::FEATURES => "/flags/",
+        Impl::DataStore::SEGMENTS => "/segments/",
+      }
+
+      class StreamProcessor
+        def initialize(sdk_key, config, diagnostic_accumulator = nil)
+          @sdk_key = sdk_key
+          @config = config
+          @diagnostic_accumulator = diagnostic_accumulator
+          @data_source_update_sink = config.data_source_update_sink
+          @feature_store = config.feature_store
+          @initialized = Concurrent::AtomicBoolean.new(false)
+          @started = Concurrent::AtomicBoolean.new(false)
+          @stopped = Concurrent::AtomicBoolean.new(false)
+          @ready = Concurrent::Event.new
+          @connection_attempt_start_time = 0
+        end
+
+        def initialized?
+          @initialized.value
+        end
+
+        def start
+          return @ready unless @started.make_true
+
+          @config.logger.info { "[LDClient] Initializing stream connection" }
+
+          headers = Impl::Util.default_http_headers(@sdk_key, @config)
+          opts = {
+            headers: headers,
+            read_timeout: READ_TIMEOUT_SECONDS,
+            logger: @config.logger,
+            socket_factory: @config.socket_factory,
+            reconnect_time: @config.initial_reconnect_delay,
+          }
+          log_connection_started
+
+          uri = Impl::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}" }
+
+                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_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
+
+          @ready
+        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
+
+        #
+        # 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}" }
+
+          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 [Impl::DataStore::FEATURES, Impl::DataStore::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
+            elsif method == DELETE
+              data = JSON.parse(message.data, symbolize_names: true)
+              for kind in [Impl::DataStore::FEATURES, Impl::DataStore::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
+
+            @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
+
+        def key_for_path(kind, path)
+          path.start_with?(KEY_PATHS[kind]) ? path[KEY_PATHS[kind].length..-1] : nil
+        end
+
+        def log_connection_started
+          @connection_attempt_start_time = Impl::Util::current_time_millis
+        end
+
+        def log_connection_result(is_success)
+          if !@diagnostic_accumulator.nil? && @connection_attempt_start_time > 0
+            @diagnostic_accumulator.record_stream_init(@connection_attempt_start_time, !is_success,
+              Impl::Util::current_time_millis - @connection_attempt_start_time)
+            @connection_attempt_start_time = 0
+          end
+        end
+      end
+    end
+  end
+end
+

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

@@ -52,7 +52,7 @@ module LaunchDarkly
           monitor_store_update do
             if @flag_change_broadcaster.has_listeners?
               old_data = {}
-              LaunchDarkly::ALL_KINDS.each do |kind|
+              Impl::DataStore::ALL_KINDS.each do |kind|
                 old_data[kind] = @data_store.all(kind)
               end
             end
@@ -153,7 +153,7 @@ module LaunchDarkly
         private def compute_changed_items_for_full_data_set(old_data, new_data)
           affected_items = Set.new
 
-          LaunchDarkly::ALL_KINDS.each do |kind|
+          Impl::DataStore::ALL_KINDS.each do |kind|
             old_items = old_data[kind] || {}
             new_items = new_data[kind] || {}
 
@@ -177,7 +177,7 @@ module LaunchDarkly
         #
         private def send_change_events(affected_items)
           affected_items.each do |item|
-            if item[:kind] == LaunchDarkly::FEATURES
+            if item[:kind] == Impl::DataStore::FEATURES
               @flag_change_broadcaster.broadcast(LaunchDarkly::Interfaces::FlagChange.new(item[:key]))
             end
           end

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

@@ -0,0 +1,108 @@
+require 'concurrent'
+require "ldclient-rb/interfaces"
+
+module LaunchDarkly
+  module Impl
+    module DataStore
+      class DataKind
+        FEATURES = "features".freeze
+        SEGMENTS = "segments".freeze
+
+        FEATURE_PREREQ_FN = lambda { |flag| (flag[:prerequisites] || []).map { |p| p[:key] } }.freeze
+
+        attr_reader :namespace
+        attr_reader :priority
+
+        #
+        # @param namespace [String]
+        # @param priority [Integer]
+        #
+        def initialize(namespace:, priority:)
+          @namespace = namespace
+          @priority = priority
+        end
+
+        #
+        # Maintain the same behavior when these data kinds were standard ruby hashes.
+        #
+        # @param key [Symbol]
+        # @return [Object]
+        #
+        def [](key)
+          return priority if key == :priority
+          return namespace if key == :namespace
+          return get_dependency_keys_fn() if key == :get_dependency_keys
+          nil
+        end
+
+        #
+        # Retrieve the dependency keys for a particular data kind. Right now, this is only defined for flags.
+        #
+        def get_dependency_keys_fn()
+          return nil unless @namespace == FEATURES
+
+          FEATURE_PREREQ_FN
+        end
+
+        def eql?(other)
+          other.is_a?(DataKind) && namespace == other.namespace && priority == other.priority
+        end
+
+        def hash
+          [namespace, priority].hash
+        end
+      end
+
+      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