launchdarkly-server-sdk 5.5.7

data/lib/ldclient-rb/memoized_value.rb

@@ -0,0 +1,32 @@
+
+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
+        if !@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/newrelic.rb

@@ -0,0 +1,17 @@
+module LaunchDarkly
+  # @private
+  class LDNewRelic
+    begin
+      require "newrelic_rpm"
+      NR_ENABLED = defined?(::NewRelic::Agent.add_custom_parameters)
+    rescue ScriptError, StandardError
+      NR_ENABLED = false
+    end
+
+    def self.annotate_transaction(key, value)
+      if NR_ENABLED
+        ::NewRelic::Agent.add_custom_parameters(key.to_s => value.to_s)
+      end
+    end
+  end
+end

data/lib/ldclient-rb/non_blocking_thread_pool.rb

@@ -0,0 +1,46 @@
+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)
+      @capacity = capacity
+      @pool = Concurrent::FixedThreadPool.new(capacity)
+      @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
+      if !@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

@@ -0,0 +1,78 @@
+require "concurrent/atomics"
+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)
+      @stopped = Concurrent::AtomicBoolean.new(false)
+      @ready = Concurrent::Event.new
+    end
+
+    def initialized?
+      @initialized.value
+    end
+
+    def start
+      return @ready unless @started.make_true
+      @config.logger.info { "[LDClient] Initializing polling connection" }
+      create_worker
+      @ready
+    end
+
+    def stop
+      if @stopped.make_true
+        if @worker && @worker.alive? && @worker != Thread.current
+          @worker.run  # causes the thread to wake up if it's currently in a sleep
+          @worker.join
+        end
+        @config.logger.info { "[LDClient] Polling connection stopped" }
+      end
+    end
+
+    def poll
+      all_data = @requestor.request_all_data
+      if all_data
+        @config.feature_store.init({
+          FEATURES => all_data[:flags],
+          SEGMENTS => all_data[:segments]
+        })
+        if @initialized.make_true
+          @config.logger.info { "[LDClient] Polling connection initialized" }
+          @ready.set
+        end
+      end
+    end
+
+    def create_worker
+      @worker = Thread.new do
+        @config.logger.debug { "[LDClient] Starting polling worker" }
+        while !@stopped.value do
+          started_at = Time.now
+          begin
+            poll
+          rescue UnexpectedResponseError => e
+            message = Util.http_error_message(e.status, "polling request", "will retry")
+            @config.logger.error { "[LDClient] #{message}" };
+            if !Util.http_error_recoverable?(e.status)
+              @ready.set  # if client was waiting on us, make it stop waiting - has no effect if already set
+              stop
+            end
+          rescue StandardError => exn
+            Util.log_exception(@config.logger, "Exception while polling", exn)
+          end
+          delta = @config.poll_interval - (Time.now - started_at)
+          if delta > 0
+            sleep(delta)
+          end
+        end
+      end
+    end
+
+    private :poll, :create_worker
+  end
+end

data/lib/ldclient-rb/redis_store.rb

@@ -0,0 +1,87 @@
+require "ldclient-rb/interfaces"
+require "ldclient-rb/impl/integrations/redis_impl"
+
+module LaunchDarkly
+  #
+  # An implementation of the LaunchDarkly client's feature store that uses a Redis
+  # instance.  This object holds feature flags and related data received from the
+  # streaming API.  Feature data can also be further cached in memory to reduce overhead
+  # of calls to Redis.
+  #
+  # To use this class, you must first have the `redis` and `connection-pool` gems
+  # installed.  Then, create an instance and store it in the `feature_store` property
+  # of your client configuration.
+  #
+  # @deprecated Use the factory method in {LaunchDarkly::Integrations::Redis} instead. This specific
+  #   implementation class may be changed or removed in the future.
+  #
+  class RedisFeatureStore
+    include LaunchDarkly::Interfaces::FeatureStore
+
+    # Note that this class is now just a facade around CachingStoreWrapper, which is in turn delegating
+    # to RedisFeatureStoreCore where the actual database logic is. This class was retained for historical
+    # reasons, so that existing code can still call RedisFeatureStore.new. In the future, we will migrate
+    # away from exposing these concrete classes and use factory methods instead.
+
+    #
+    # Constructor for a RedisFeatureStore instance.
+    #
+    # @param opts [Hash] the configuration options
+    # @option opts [String] :redis_url  URL of the Redis instance (shortcut for omitting redis_opts)
+    # @option opts [Hash] :redis_opts  options to pass to the Redis constructor (if you want to specify more than just redis_url)
+    # @option opts [String] :prefix  namespace prefix to add to all hash keys used by LaunchDarkly
+    # @option opts [Logger] :logger  a `Logger` instance; defaults to `Config.default_logger`
+    # @option opts [Integer] :max_connections  size of the Redis connection pool
+    # @option opts [Integer] :expiration  expiration time for the in-memory cache, in seconds; 0 for no local caching
+    # @option opts [Integer] :capacity  maximum number of feature flags (or related objects) to cache locally
+    # @option opts [Object] :pool  custom connection pool, if desired
+    #
+    def initialize(opts = {})
+      core = LaunchDarkly::Impl::Integrations::Redis::RedisFeatureStoreCore.new(opts)
+      @wrapper = LaunchDarkly::Integrations::Util::CachingStoreWrapper.new(core, opts)
+    end
+
+    #
+    # Default value for the `redis_url` constructor parameter; points to an instance of Redis
+    # running at `localhost` with its default port.
+    #
+    def self.default_redis_url
+      LaunchDarkly::Integrations::Redis::default_redis_url
+    end
+
+    #
+    # Default value for the `prefix` constructor parameter.
+    #
+    def self.default_prefix
+      LaunchDarkly::Integrations::Redis::default_prefix
+    end
+
+    def get(kind, key)
+      @wrapper.get(kind, key)
+    end
+
+    def all(kind)
+      @wrapper.all(kind)
+    end
+
+    def delete(kind, key, version)
+      @wrapper.delete(kind, key, version)
+    end
+
+    def init(all_data)
+      @wrapper.init(all_data)
+    end
+
+    def upsert(kind, item)
+      @wrapper.upsert(kind, item)
+    end
+
+    def initialized?
+      @wrapper.initialized?
+    end
+
+    def stop
+      @wrapper.stop
+    end
+  end
+end

data/lib/ldclient-rb/requestor.rb

@@ -0,0 +1,101 @@
+require "concurrent/atomics"
+require "json"
+require "uri"
+
+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
+      @client = Util.new_http_client(@config.base_uri, @config)
+      @cache = @config.cache_store
+    end
+
+    def request_flag(key)
+      make_request("/sdk/latest-flags/" + key)
+    end
+
+    def request_segment(key)
+      make_request("/sdk/latest-segments/" + key)
+    end
+
+    def request_all_data()
+      make_request("/sdk/latest-all")
+    end
+    
+    def stop
+      begin
+        @client.finish
+      rescue
+      end
+    end
+
+    private
+
+    def make_request(path)
+      @client.start if !@client.started?
+      uri = URI(@config.base_uri + path)
+      req = Net::HTTP::Get.new(uri)
+      req["Authorization"] = @sdk_key
+      req["User-Agent"] = "RubyClient/" + LaunchDarkly::VERSION
+      req["Connection"] = "keep-alive"
+      cached = @cache.read(uri)
+      if !cached.nil?
+        req["If-None-Match"] = cached.etag
+      end
+      res = @client.request(req)
+      status = res.code.to_i
+      @config.logger.debug { "[LDClient] Got response from uri: #{uri}\n\tstatus code: #{status}\n\theaders: #{res.to_hash}\n\tbody: #{res.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(res.body, res["content-type"])
+        etag = res["etag"]
+        @cache.write(uri, CacheEntry.new(etag, body)) if !etag.nil?
+      end
+      JSON.parse(body, symbolize_names: true)
+    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
+      return [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,141 @@
+require "concurrent/atomics"
+require "json"
+require "ld-eventsource"
+
+module LaunchDarkly
+  # @private
+  PUT = :put
+  # @private
+  PATCH = :patch
+  # @private
+  DELETE = :delete
+  # @private
+  INDIRECT_PUT = :'indirect/put'
+  # @private
+  INDIRECT_PATCH = :'indirect/patch'
+  # @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, requestor)
+      @sdk_key = sdk_key
+      @config = config
+      @feature_store = config.feature_store
+      @requestor = requestor
+      @initialized = Concurrent::AtomicBoolean.new(false)
+      @started = Concurrent::AtomicBoolean.new(false)
+      @stopped = Concurrent::AtomicBoolean.new(false)
+      @ready = Concurrent::Event.new
+    end
+
+    def initialized?
+      @initialized.value
+    end
+
+    def start
+      return @ready unless @started.make_true
+
+      @config.logger.info { "[LDClient] Initializing stream connection" }
+      
+      headers = {
+        'Authorization' => @sdk_key,
+        'User-Agent' => 'RubyClient/' + LaunchDarkly::VERSION
+      }
+      opts = {
+        headers: headers,
+        read_timeout: READ_TIMEOUT_SECONDS,
+        logger: @config.logger
+      }
+      @es = SSE::Client.new(@config.stream_uri + "/all", **opts) do |conn|
+        conn.on_event { |event| process_message(event) }
+        conn.on_error { |err|
+          case err
+          when SSE::Errors::HTTPStatusError
+            status = err.status
+            message = Util.http_error_message(status, "streaming connection", "will retry")
+            @config.logger.error { "[LDClient] #{message}" }
+            if !Util.http_error_recoverable?(status)
+              @ready.set  # if client was waiting on us, make it stop waiting - has no effect if already set
+              stop
+            end
+          end
+        }
+      end
+      
+      @ready
+    end
+
+    def stop
+      if @stopped.make_true
+        @es.close
+        @config.logger.info { "[LDClient] Stream connection stopped" }
+      end
+    end
+
+    private
+
+    def process_message(message)
+      method = message.type
+      @config.logger.debug { "[LDClient] Stream received #{method} message: #{message.data}" }
+      if method == PUT
+        message = JSON.parse(message.data, symbolize_names: true)
+        @feature_store.init({
+          FEATURES => message[:data][:flags],
+          SEGMENTS => message[:data][:segments]
+        })
+        @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
+            @feature_store.upsert(kind, data[:data])
+            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
+            @feature_store.delete(kind, key, data[:version])
+            break
+          end
+        end
+      elsif method == INDIRECT_PUT
+        all_data = @requestor.request_all_data
+        @feature_store.init({
+          FEATURES => all_data[:flags],
+          SEGMENTS => all_data[:segments]
+        })
+        @initialized.make_true
+        @config.logger.info { "[LDClient] Stream initialized (via indirect message)" }
+      elsif method == INDIRECT_PATCH
+        key = key_for_path(FEATURES, message.data)
+        if key
+          @feature_store.upsert(FEATURES, @requestor.request_flag(key))
+        else
+          key = key_for_path(SEGMENTS, message.data)
+          if key
+            @feature_store.upsert(SEGMENTS, @requestor.request_segment(key))
+          end
+        end
+      else
+        @config.logger.warn { "[LDClient] Unknown message received: #{method}" }
+      end
+    end
+
+    def key_for_path(kind, path)
+      path.start_with?(KEY_PATHS[kind]) ? path[KEY_PATHS[kind].length..-1] : nil
+    end
+  end
+end