launchdarkly-server-sdk 8.11.2 → 8.11.3

data/lib/ldclient-rb/cache_store.rb

@@ -1,45 +0,0 @@
-require "concurrent/map"
-
-module LaunchDarkly
-  #
-  # A thread-safe in-memory store that uses the same semantics that Faraday would expect, although we
-  # no longer use Faraday. This is used by Requestor, when we are not in a Rails environment.
-  #
-  # @private
-  #
-  class ThreadSafeMemoryStore
-    #
-    # Default constructor
-    #
-    # @return [ThreadSafeMemoryStore] a new store
-    def initialize
-      @cache = Concurrent::Map.new
-    end
-
-    #
-    # Read a value from the cache
-    # @param key [Object] the cache key
-    #
-    # @return [Object] the cache value
-    def read(key)
-      @cache[key]
-    end
-
-    #
-    # Store a value in the cache
-    # @param key [Object] the cache key
-    # @param value [Object] the value to associate with the key
-    #
-    # @return [Object] the value
-    def write(key, value)
-      @cache[key] = value
-    end
-
-    #
-    # Delete a value in the cache
-    # @param key [Object] the cache key
-    def delete(key)
-      @cache.delete(key)
-    end
-  end
-end

data/lib/ldclient-rb/expiring_cache.rb

@@ -1,77 +0,0 @@
-
-module LaunchDarkly
-  # A thread-safe cache with maximum number of entries and TTL.
-  # Adapted from https://github.com/SamSaffron/lru_redux/blob/master/lib/lru_redux/ttl/cache.rb
-  # under MIT license with the following changes:
-  #   * made thread-safe
-  #   * removed many unused methods
-  #   * reading a key does not reset its expiration time, only writing
-  # @private
-  class ExpiringCache
-    def initialize(max_size, ttl)
-      @max_size = max_size
-      @ttl = ttl
-      @data_lru = {}
-      @data_ttl = {}
-      @lock = Mutex.new
-    end
-
-    def [](key)
-      @lock.synchronize do
-        ttl_evict
-        @data_lru[key]
-      end
-    end
-
-    def []=(key, val)
-      @lock.synchronize do
-        ttl_evict
-
-        @data_lru.delete(key)
-        @data_ttl.delete(key)
-
-        @data_lru[key] = val
-        @data_ttl[key] = Time.now.to_f
-
-        if @data_lru.size > @max_size
-          key, _ = @data_lru.first # hashes have a FIFO ordering in Ruby
-
-          @data_ttl.delete(key)
-          @data_lru.delete(key)
-        end
-
-        val
-      end
-    end
-
-    def delete(key)
-      @lock.synchronize do
-        ttl_evict
-
-        @data_lru.delete(key)
-        @data_ttl.delete(key)
-      end
-    end
-
-    def clear
-      @lock.synchronize do
-        @data_lru.clear
-        @data_ttl.clear
-      end
-    end
-
-    private
-
-    def ttl_evict
-      ttl_horizon = Time.now.to_f - @ttl
-      key, time = @data_ttl.first
-
-      until time.nil? || time > ttl_horizon
-        @data_ttl.delete(key)
-        @data_lru.delete(key)
-
-        key, time = @data_ttl.first
-      end
-    end
-  end
-end

data/lib/ldclient-rb/memoized_value.rb

@@ -1,32 +0,0 @@
-
-module LaunchDarkly
-  # Simple implementation of a thread-safe memoized value whose generator function will never be
-  # run more than once, and whose value can be overridden by explicit assignment.
-  # Note that we no longer use this class and it will be removed in a future version.
-  # @private
-  class MemoizedValue
-    def initialize(&generator)
-      @generator = generator
-      @mutex = Mutex.new
-      @inited = false
-      @value = nil
-    end
-
-    def get
-      @mutex.synchronize do
-        unless @inited
-          @value = @generator.call
-          @inited = true
-        end
-      end
-      @value
-    end
-
-    def set(value)
-      @mutex.synchronize do
-        @value = value
-        @inited = true
-      end
-    end
-  end
-end

data/lib/ldclient-rb/non_blocking_thread_pool.rb

@@ -1,46 +0,0 @@
-require "concurrent"
-require "concurrent/atomics"
-require "concurrent/executors"
-require "thread"
-
-module LaunchDarkly
-  # Simple wrapper for a FixedThreadPool that rejects new jobs if all the threads are busy, rather
-  # than blocking. Also provides a way to wait for all jobs to finish without shutting down.
-  # @private
-  class NonBlockingThreadPool
-    def initialize(capacity, name = 'LD/NonBlockingThreadPool')
-      @capacity = capacity
-      @pool = Concurrent::FixedThreadPool.new(capacity, name: name)
-      @semaphore = Concurrent::Semaphore.new(capacity)
-    end
-
-    # Attempts to submit a job, but only if a worker is available. Unlike the regular post method,
-    # this returns a value: true if the job was submitted, false if all workers are busy.
-    def post
-      unless @semaphore.try_acquire(1)
-        return
-      end
-      @pool.post do
-        begin
-          yield
-        ensure
-          @semaphore.release(1)
-        end
-      end
-    end
-
-    # Waits until no jobs are executing, without shutting down the pool.
-    def wait_all
-      @semaphore.acquire(@capacity)
-      @semaphore.release(@capacity)
-    end
-
-    def shutdown
-      @pool.shutdown
-    end
-
-    def wait_for_termination
-      @pool.wait_for_termination
-    end
-  end
-end

data/lib/ldclient-rb/polling.rb

@@ -1,102 +0,0 @@
-require "ldclient-rb/impl/repeating_task"
-
-require "concurrent/atomics"
-require "json"
-require "thread"
-
-module LaunchDarkly
-  # @private
-  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 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
-        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

@@ -1,102 +0,0 @@
-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

@@ -1,25 +0,0 @@
-
-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

@@ -1,197 +0,0 @@
-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
-      @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 = 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