launchdarkly-server-sdk 8.8.3-java

data/lib/ldclient-rb/requestor.rb

@@ -0,0 +1,102 @@
+require "ldclient-rb/impl/model/serialization"
+
+require "concurrent/atomics"
+require "json"
+require "uri"
+require "http"
+
+module LaunchDarkly
+  # @private
+  class UnexpectedResponseError < StandardError
+    def initialize(status)
+      @status = status
+      super("HTTP error #{status}")
+    end
+
+    def status
+      @status
+    end
+  end
+
+  # @private
+  class Requestor
+    CacheEntry = Struct.new(:etag, :body)
+
+    def initialize(sdk_key, config)
+      @sdk_key = sdk_key
+      @config = config
+      @http_client = LaunchDarkly::Util.new_http_client(config.base_uri, 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(@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

data/lib/ldclient-rb/simple_lru_cache.rb

@@ -0,0 +1,25 @@
+
+module LaunchDarkly
+  # A non-thread-safe implementation of a LRU cache set with only add and reset methods.
+  # Based on https://github.com/SamSaffron/lru_redux/blob/master/lib/lru_redux/cache.rb
+  # @private
+  class SimpleLRUCacheSet
+    def initialize(capacity)
+      @values = {}
+      @capacity = capacity
+    end
+
+    # Adds a value to the cache or marks it recent if it was already there. Returns true if already there.
+    def add(value)
+      found = true
+      @values.delete(value) { found = false }
+      @values[value] = true
+      @values.shift if @values.length > @capacity
+      found
+    end
+
+    def clear
+      @values = {}
+    end
+  end
+end

data/lib/ldclient-rb/stream.rb

@@ -0,0 +1,196 @@
+require "ldclient-rb/impl/model/serialization"
+
+require "concurrent/atomics"
+require "json"
+require "ld-eventsource"
+
+module LaunchDarkly
+  # @private
+  PUT = :put
+  # @private
+  PATCH = :patch
+  # @private
+  DELETE = :delete
+  # @private
+  READ_TIMEOUT_SECONDS = 300  # 5 minutes; the stream should send a ping every 3 minutes
+
+  # @private
+  KEY_PATHS = {
+    FEATURES => "/flags/",
+    SEGMENTS => "/segments/",
+  }
+
+  # @private
+  class StreamProcessor
+    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)
+      @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 = 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 [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
+        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
+
+        @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

data/lib/ldclient-rb/util.rb

@@ -0,0 +1,132 @@
+require "uri"
+require "http"
+
+module LaunchDarkly
+  #
+  # A Result is used to reflect the outcome of any operation.
+  #
+  # Results can either be considered a success or a failure.
+  #
+  # In the event of success, the Result will contain an option, nullable value to hold any success value back to the
+  # calling function.
+  #
+  # If the operation fails, the Result will contain an error describing the value.
+  #
+  class Result
+    #
+    # Create a successful result with the provided value.
+    #
+    # @param value [Object, nil]
+    # @return [Result]
+    #
+    def self.success(value)
+      Result.new(value)
+    end
+
+    #
+    # Create a failed result with the provided error description.
+    #
+    # @param error [String]
+    # @param exception [Exception, nil]
+    # @return [Result]
+    #
+    def self.fail(error, exception = nil)
+      Result.new(nil, error, exception)
+    end
+
+    #
+    # Was this result successful or did it encounter an error?
+    #
+    # @return [Boolean]
+    #
+    def success?
+      @error.nil?
+    end
+
+    #
+    # @return [Object, nil] The value returned from the operation if it was successful; nil otherwise.
+    #
+    attr_reader :value
+
+    #
+    # @return [String, nil] An error description of the failure; nil otherwise
+    #
+    attr_reader :error
+
+    #
+    # @return [Exception, nil] An optional exception which caused the failure
+    #
+    attr_reader :exception
+
+    private def initialize(value, error = nil, exception = nil)
+      @value = value
+      @error = error
+      @exception = exception
+    end
+  end
+
+  # @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?
+
+      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
+        http_client_options["socket_class"] = config.socket_factory
+      end
+      proxy = URI.parse(uri_s).find_proxy
+      unless proxy.nil?
+        http_client_options["proxy"] = {
+          proxy_address: proxy.host,
+          proxy_port: proxy.port,
+          proxy_username: proxy.user,
+          proxy_password: proxy.password,
+        }
+      end
+      HTTP::Client.new(http_client_options)
+        .timeout({
+          read: config.read_timeout,
+          connect: config.connect_timeout,
+        })
+        .persistent(uri_s)
+    end
+
+    def self.log_exception(logger, message, exc)
+      logger.error { "[LDClient] #{message}: #{exc.inspect}" }
+      logger.debug { "[LDClient] Exception trace: #{exc.backtrace}" }
+    end
+
+    def self.http_error_recoverable?(status)
+      if status >= 400 && status < 500
+        status == 400 || status == 408 || status == 429
+      else
+        true
+      end
+    end
+
+    def self.http_error_message(status, context, recoverable_message)
+      desc = (status == 401 || status == 403) ? " (invalid SDK key)" : ""
+      message = Util.http_error_recoverable?(status) ? recoverable_message : "giving up permanently"
+      "HTTP error #{status}#{desc} for #{context} - #{message}"
+    end
+  end
+end

data/lib/ldclient-rb/version.rb

@@ -0,0 +1,3 @@
+module LaunchDarkly
+  VERSION = "8.8.3" # x-release-please-version
+end

data/lib/ldclient-rb.rb

@@ -0,0 +1,27 @@
+
+#
+# Namespace for the LaunchDarkly Ruby SDK.
+#
+module LaunchDarkly
+end
+
+require "ldclient-rb/version"
+require "ldclient-rb/interfaces"
+require "ldclient-rb/util"
+require "ldclient-rb/flags_state"
+require "ldclient-rb/migrations"
+require "ldclient-rb/ldclient"
+require "ldclient-rb/cache_store"
+require "ldclient-rb/expiring_cache"
+require "ldclient-rb/memoized_value"
+require "ldclient-rb/in_memory_store"
+require "ldclient-rb/config"
+require "ldclient-rb/context"
+require "ldclient-rb/reference"
+require "ldclient-rb/stream"
+require "ldclient-rb/polling"
+require "ldclient-rb/simple_lru_cache"
+require "ldclient-rb/non_blocking_thread_pool"
+require "ldclient-rb/events"
+require "ldclient-rb/requestor"
+require "ldclient-rb/integrations"