launchdarkly-server-sdk 6.3.0 → 8.0.0

data/lib/ldclient-rb/impl/integrations/consul_impl.rb

@@ -16,14 +16,14 @@ module LaunchDarkly
           end
 
           def initialize(opts)
-            if !CONSUL_ENABLED
+            unless CONSUL_ENABLED
               raise RuntimeError.new("can't use Consul feature store without the 'diplomat' gem")
             end
 
             @prefix = (opts[:prefix] || LaunchDarkly::Integrations::Consul.default_prefix) + '/'
             @logger = opts[:logger] || Config.default_logger
-            Diplomat.configuration = opts[:consul_config] if !opts[:consul_config].nil?
-            Diplomat.configuration.url = opts[:url] if !opts[:url].nil?
+            Diplomat.configuration = opts[:consul_config] unless opts[:consul_config].nil?
+            Diplomat.configuration.url = opts[:url] unless opts[:url].nil?
             @logger.info("ConsulFeatureStore: using Consul host at #{Diplomat.configuration.url}")
           end
 
@@ -51,10 +51,10 @@ module LaunchDarkly
             unused_old_keys.each do |key|
               ops.push({ 'KV' => { 'Verb' => 'delete', 'Key' => key } })
             end
-    
+
             # Now set the special key that we check in initialized_internal?
             ops.push({ 'KV' => { 'Verb' => 'set', 'Key' => inited_key, 'Value' => '' } })
-            
+
             ConsulUtil.batch_operations(ops)
 
             @logger.info { "Initialized database with #{num_items} items" }
@@ -70,7 +70,7 @@ module LaunchDarkly
             results = Diplomat::Kv.get(kind_key(kind), { recurse: true }, :return)
             (results == "" ? [] : results).each do |result|
               value = result[:value]
-              if !value.nil?
+              unless value.nil?
                 item = Model.deserialize(kind, value)
                 items_out[item[:key].to_sym] = item
               end
@@ -119,6 +119,18 @@ module LaunchDarkly
             end
           end
 
+          def available?
+            # Most implementations use the initialized_internal? method as a
+            # proxy for this check. However, since `initialized_internal?`
+            # catches a KeyNotFound exception, and that exception can be raised
+            # when the server goes away, we have to modify our behavior
+            # slightly.
+            Diplomat::Kv.get(inited_key, {}, :return, :return)
+            true
+          rescue
+            false
+          end
+
           def stop
             # There's no Consul client instance to dispose of
           end
@@ -132,7 +144,7 @@ module LaunchDarkly
           def kind_key(kind)
             @prefix + kind[:namespace] + '/'
           end
-          
+
           def inited_key
             @prefix + '$inited'
           end

data/lib/ldclient-rb/impl/integrations/dynamodb_impl.rb

@@ -16,28 +16,28 @@ module LaunchDarkly
               AWS_SDK_ENABLED = false
             end
           end
-  
+
           PARTITION_KEY = "namespace"
           SORT_KEY = "key"
 
           def initialize(table_name, opts)
-            if !AWS_SDK_ENABLED
+            unless AWS_SDK_ENABLED
               raise RuntimeError.new("can't use #{description} without the aws-sdk or aws-sdk-dynamodb gem")
             end
-  
+
             @table_name = table_name
             @prefix = opts[:prefix] ? (opts[:prefix] + ":") : ""
             @logger = opts[:logger] || Config.default_logger
-  
+
             if !opts[:existing_client].nil?
               @client = opts[:existing_client]
             else
               @client = Aws::DynamoDB::Client.new(opts[:dynamodb_opts] || {})
             end
-  
-            @logger.info("${description}: using DynamoDB table \"#{table_name}\"")
+
+            @logger.info("#{description}: using DynamoDB table \"#{table_name}\"")
           end
-  
+
           def stop
             # AWS client doesn't seem to have a close method
           end
@@ -46,7 +46,7 @@ module LaunchDarkly
             "DynamoDB"
           end
         end
-  
+
         #
         # Internal implementation of the DynamoDB feature store, intended to be used with CachingStoreWrapper.
         #
@@ -62,6 +62,14 @@ module LaunchDarkly
             "DynamoDBFeatureStore"
           end
 
+          def available?
+            resp = get_item_by_keys(inited_key, inited_key)
+            !resp.item.nil? && resp.item.length > 0
+            true
+          rescue
+            false
+          end
+
           def init_internal(all_data)
             # Start by reading the existing keys; we will later delete any of these that weren't in all_data.
             unused_old_keys = read_existing_keys(all_data.keys)
@@ -83,7 +91,7 @@ module LaunchDarkly
               del_item = make_keys_hash(tuple[0], tuple[1])
               requests.push({ delete_request: { key: del_item } })
             end
-    
+
             # Now set the special key that we check in initialized_internal?
             inited_item = make_keys_hash(inited_key, inited_key)
             requests.push({ put_request: { item: inited_item } })
@@ -123,11 +131,11 @@ module LaunchDarkly
                 expression_attribute_names: {
                   "#namespace" => PARTITION_KEY,
                   "#key" => SORT_KEY,
-                  "#version" => VERSION_ATTRIBUTE
+                  "#version" => VERSION_ATTRIBUTE,
                 },
                 expression_attribute_values: {
-                  ":version" => new_item[:version]
-                }
+                  ":version" => new_item[:version],
+                },
               })
               new_item
             rescue Aws::DynamoDB::Errors::ConditionalCheckFailedException
@@ -159,7 +167,7 @@ module LaunchDarkly
           def make_keys_hash(namespace, key)
             {
               PARTITION_KEY => namespace,
-              SORT_KEY => key
+              SORT_KEY => key,
             }
           end
 
@@ -170,16 +178,16 @@ module LaunchDarkly
               key_conditions: {
                 PARTITION_KEY => {
                   comparison_operator: "EQ",
-                  attribute_value_list: [ namespace_for_kind(kind) ]
-                }
-              }
+                  attribute_value_list: [ namespace_for_kind(kind) ],
+                },
+              },
             }
           end
 
           def get_item_by_keys(namespace, key)
             @client.get_item({
               table_name: @table_name,
-              key: make_keys_hash(namespace, key)
+              key: make_keys_hash(namespace, key),
             })
           end
 
@@ -190,8 +198,8 @@ module LaunchDarkly
                 projection_expression: "#namespace, #key",
                 expression_attribute_names: {
                   "#namespace" => PARTITION_KEY,
-                  "#key" => SORT_KEY
-                }
+                  "#key" => SORT_KEY,
+                },
               })
               while true
                 resp = @client.query(req)
@@ -210,7 +218,7 @@ module LaunchDarkly
           def marshal_item(kind, item)
             make_keys_hash(namespace_for_kind(kind), item[:key]).merge({
               VERSION_ATTRIBUTE => item[:version],
-              ITEM_JSON_ATTRIBUTE => Model.serialize(kind, item)
+              ITEM_JSON_ATTRIBUTE => Model.serialize(kind, item),
             })
           end
 
@@ -223,11 +231,11 @@ module LaunchDarkly
         end
 
         class DynamoDBBigSegmentStore < DynamoDBStoreImplBase
-          KEY_METADATA = 'big_segments_metadata';
-          KEY_USER_DATA = 'big_segments_user';
-          ATTR_SYNC_TIME = 'synchronizedOn';
-          ATTR_INCLUDED = 'included';
-          ATTR_EXCLUDED = 'excluded';
+          KEY_METADATA = 'big_segments_metadata'
+          KEY_CONTEXT_DATA = 'big_segments_user'
+          ATTR_SYNC_TIME = 'synchronizedOn'
+          ATTR_INCLUDED = 'included'
+          ATTR_EXCLUDED = 'excluded'
 
           def initialize(table_name, opts)
             super(table_name, opts)
@@ -243,7 +251,7 @@ module LaunchDarkly
               table_name: @table_name,
               key: {
                 PARTITION_KEY => key,
-                SORT_KEY => key
+                SORT_KEY => key,
               }
             )
             timestamp = data.item && data.item[ATTR_SYNC_TIME] ?
@@ -251,14 +259,14 @@ module LaunchDarkly
             LaunchDarkly::Interfaces::BigSegmentStoreMetadata.new(timestamp)
           end
 
-          def get_membership(user_hash)
+          def get_membership(context_hash)
             data = @client.get_item(
               table_name: @table_name,
               key: {
-                PARTITION_KEY => @prefix + KEY_USER_DATA,
-                SORT_KEY => user_hash
+                PARTITION_KEY => @prefix + KEY_CONTEXT_DATA,
+                SORT_KEY => context_hash,
               })
-            return nil if !data.item
+            return nil unless data.item
             excluded_refs = data.item[ATTR_EXCLUDED] || []
             included_refs = data.item[ATTR_INCLUDED] || []
             if excluded_refs.empty? && included_refs.empty?

data/lib/ldclient-rb/impl/integrations/file_data_source.rb

@@ -18,10 +18,18 @@ module LaunchDarkly
           require 'listen'
           @@have_listen = true
         rescue LoadError
+          # Ignored
         end
 
-        def initialize(feature_store, logger, options={})
-          @feature_store = feature_store
+        #
+        # @param data_store [LaunchDarkly::Interfaces::FeatureStore]
+        # @param data_source_update_sink [LaunchDarkly::Interfaces::DataSource::UpdateSink, nil] Might be nil for backwards compatibility reasons.
+        # @param logger [Logger]
+        # @param options [Hash]
+        #
+        def initialize(data_store, data_source_update_sink, logger, options={})
+          @data_store = data_source_update_sink || data_store
+          @data_source_update_sink = data_source_update_sink
           @logger = logger
           @paths = options[:paths] || []
           if @paths.is_a? String
@@ -48,7 +56,7 @@ module LaunchDarkly
 
         def start
           ready = Concurrent::Event.new
-          
+
           # We will return immediately regardless of whether the file load succeeded or failed -
           # the difference can be detected by checking "initialized?"
           ready.set
@@ -63,9 +71,9 @@ module LaunchDarkly
 
           ready
         end
-        
+
         def stop
-          @listener.stop if !@listener.nil?
+          @listener.stop unless @listener.nil?
         end
 
         private
@@ -73,17 +81,22 @@ module LaunchDarkly
         def load_all
           all_data = {
             FEATURES => {},
-            SEGMENTS => {}
+            SEGMENTS => {},
           }
           @paths.each do |path|
             begin
               load_file(path, all_data)
             rescue => exn
               LaunchDarkly::Util.log_exception(@logger, "Unable to load flag data from \"#{path}\"", exn)
+              @data_source_update_sink&.update_status(
+                LaunchDarkly::Interfaces::DataSource::Status::INTERRUPTED,
+                LaunchDarkly::Interfaces::DataSource::ErrorInfo.new(LaunchDarkly::Interfaces::DataSource::ErrorInfo::INVALID_DATA, 0, exn.to_s, Time.now)
+              )
               return
             end
           end
-          @feature_store.init(all_data)
+          @data_store.init(all_data)
+          @data_source_update_sink&.update_status(LaunchDarkly::Interfaces::DataSource::Status::VALID, nil)
           @initialized.make_true
         end
 
@@ -121,12 +134,12 @@ module LaunchDarkly
 
         def add_item(all_data, kind, item)
           items = all_data[kind]
-          raise ArgumentError, "Received unknown item kind #{kind} in add_data" if items.nil? # shouldn't be possible since we preinitialize the hash
+          raise ArgumentError, "Received unknown item kind #{kind[:namespace]} in add_data" if items.nil? # shouldn't be possible since we preinitialize the hash
           key = item[:key].to_sym
-          if !items[key].nil?
+          unless items[key].nil?
             raise ArgumentError, "#{kind[:namespace]} key \"#{item[:key]}\" was used more than once"
           end
-          items[key] = item
+          items[key] = Model.deserialize(kind, item)
         end
 
         def make_flag_with_value(key, value)
@@ -134,7 +147,7 @@ module LaunchDarkly
             key: key,
             on: true,
             fallthrough: { variation: 0 },
-            variations: [ value ]
+            variations: [ value ],
           }
         end
 

data/lib/ldclient-rb/impl/integrations/redis_impl.rb

@@ -1,3 +1,4 @@
+require "ldclient-rb/interfaces"
 require "concurrent/atomics"
 require "json"
 
@@ -5,6 +6,95 @@ module LaunchDarkly
   module Impl
     module Integrations
       module Redis
+        #
+        # 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.
+        #
+        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
+          # @option opts [Boolean] :pool_shutdown_on_close whether calling `close` should shutdown the custom connection pool.
+          #
+          def initialize(opts = {})
+            core = RedisFeatureStoreCore.new(opts)
+            @wrapper = LaunchDarkly::Integrations::Util::CachingStoreWrapper.new(core, opts)
+          end
+
+          def monitoring_enabled?
+            true
+          end
+
+          def available?
+            @wrapper.available?
+          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
+
         class RedisStoreImplBase
           begin
             require "redis"
@@ -15,7 +105,7 @@ module LaunchDarkly
           end
 
           def initialize(opts)
-            if !REDIS_ENABLED
+            unless REDIS_ENABLED
               raise RuntimeError.new("can't use #{description} because one of these gems is missing: redis, connection_pool")
             end
 
@@ -28,7 +118,7 @@ module LaunchDarkly
             @logger = opts[:logger] || Config.default_logger
             @test_hook = opts[:test_hook]  # used for unit tests, deliberately undocumented
 
-            @stopped = Concurrent::AtomicBoolean.new(false)
+            @stopped = Concurrent::AtomicBoolean.new
 
             with_connection do |redis|
               @logger.info("#{description}: using Redis instance at #{redis.connection[:host]}:#{redis.connection[:port]} and prefix: #{@prefix}")
@@ -55,13 +145,11 @@ module LaunchDarkly
             if opts[:redis_url]
               redis_opts[:url] = opts[:redis_url]
             end
-            if !redis_opts.include?(:url)
+            unless redis_opts.include?(:url)
               redis_opts[:url] = LaunchDarkly::Integrations::Redis::default_redis_url
             end
             max_connections = opts[:max_connections] || 16
-            return opts[:pool] || ConnectionPool.new(size: max_connections) do
-              ::Redis.new(redis_opts)
-            end
+            opts[:pool] || ConnectionPool.new(size: max_connections) { ::Redis.new(redis_opts) }
           end
         end
 
@@ -75,6 +163,14 @@ module LaunchDarkly
             @test_hook = opts[:test_hook]  # used for unit tests, deliberately undocumented
           end
 
+          def available?
+            # We don't care what the status is, only that we can connect
+            initialized_internal?
+            true
+          rescue
+            false
+          end
+
           def description
             "RedisFeatureStore"
           end
@@ -135,6 +231,7 @@ module LaunchDarkly
                   else
                     final_item = old_item
                     action = new_item[:deleted] ? "delete" : "update"
+                    # rubocop:disable Layout/LineLength
                     @logger.warn { "RedisFeatureStore: attempted to #{action} #{key} version: #{old_item[:version]} in '#{kind[:namespace]}' with a version that is the same or older: #{new_item[:version]}" }
                   end
                   redis.unwatch
@@ -151,7 +248,7 @@ module LaunchDarkly
           private
 
           def before_update_transaction(base_key, key)
-            @test_hook.before_update_transaction(base_key, key) if !@test_hook.nil?
+            @test_hook.before_update_transaction(base_key, key) unless @test_hook.nil?
           end
 
           def items_key(kind)
@@ -176,8 +273,8 @@ module LaunchDarkly
         #
         class RedisBigSegmentStore < RedisStoreImplBase
           KEY_LAST_UP_TO_DATE = ':big_segments_synchronized_on'
-          KEY_USER_INCLUDE = ':big_segment_include:'
-          KEY_USER_EXCLUDE = ':big_segment_exclude:'
+          KEY_CONTEXT_INCLUDE = ':big_segment_include:'
+          KEY_CONTEXT_EXCLUDE = ':big_segment_exclude:'
 
           def description
             "RedisBigSegmentStore"
@@ -188,10 +285,10 @@ module LaunchDarkly
             Interfaces::BigSegmentStoreMetadata.new(value.nil? ? nil : value.to_i)
           end
 
-          def get_membership(user_hash)
+          def get_membership(context_hash)
             with_connection do |redis|
-              included_refs = redis.smembers(@prefix + KEY_USER_INCLUDE + user_hash)
-              excluded_refs = redis.smembers(@prefix + KEY_USER_EXCLUDE + user_hash)
+              included_refs = redis.smembers(@prefix + KEY_CONTEXT_INCLUDE + context_hash)
+              excluded_refs = redis.smembers(@prefix + KEY_CONTEXT_EXCLUDE + context_hash)
               if !included_refs && !excluded_refs
                 nil
               else