launchdarkly-server-sdk 6.2.5 → 7.0.0

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

@@ -4,10 +4,7 @@ module LaunchDarkly
   module Impl
     module Integrations
       module DynamoDB
-        #
-        # Internal implementation of the DynamoDB feature store, intended to be used with CachingStoreWrapper.
-        #
-        class DynamoDBFeatureStoreCore
+        class DynamoDBStoreImplBase
           begin
             require "aws-sdk-dynamodb"
             AWS_SDK_ENABLED = true
@@ -23,16 +20,13 @@ module LaunchDarkly
           PARTITION_KEY = "namespace"
           SORT_KEY = "key"
 
-          VERSION_ATTRIBUTE = "version"
-          ITEM_JSON_ATTRIBUTE = "item"
-
           def initialize(table_name, opts)
-            if !AWS_SDK_ENABLED
-              raise RuntimeError.new("can't use DynamoDB feature store without the aws-sdk or aws-sdk-dynamodb gem")
+            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]
+            @prefix = opts[:prefix] ? (opts[:prefix] + ":") : ""
             @logger = opts[:logger] || Config.default_logger
 
             if !opts[:existing_client].nil?
@@ -41,7 +35,31 @@ module LaunchDarkly
               @client = Aws::DynamoDB::Client.new(opts[:dynamodb_opts] || {})
             end
 
-            @logger.info("DynamoDBFeatureStore: 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
+
+          protected def description
+            "DynamoDB"
+          end
+        end
+
+        #
+        # Internal implementation of the DynamoDB feature store, intended to be used with CachingStoreWrapper.
+        #
+        class DynamoDBFeatureStoreCore < DynamoDBStoreImplBase
+          VERSION_ATTRIBUTE = "version"
+          ITEM_JSON_ATTRIBUTE = "item"
+
+          def initialize(table_name, opts)
+            super(table_name, opts)
+          end
+
+          def description
+            "DynamoDBFeatureStore"
           end
 
           def init_internal(all_data)
@@ -65,7 +83,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 } })
@@ -105,11 +123,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
@@ -124,14 +142,10 @@ module LaunchDarkly
             !resp.item.nil? && resp.item.length > 0
           end
 
-          def stop
-            # AWS client doesn't seem to have a close method
-          end
-
           private
 
           def prefixed_namespace(base_str)
-            (@prefix.nil? || @prefix == "") ? base_str : "#{@prefix}:#{base_str}"
+            @prefix + base_str
           end
 
           def namespace_for_kind(kind)
@@ -145,7 +159,7 @@ module LaunchDarkly
           def make_keys_hash(namespace, key)
             {
               PARTITION_KEY => namespace,
-              SORT_KEY => key
+              SORT_KEY => key,
             }
           end
 
@@ -156,16 +170,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
 
@@ -176,8 +190,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)
@@ -196,7 +210,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
 
@@ -208,6 +222,56 @@ module LaunchDarkly
           end
         end
 
+        class DynamoDBBigSegmentStore < DynamoDBStoreImplBase
+          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)
+          end
+
+          def description
+            "DynamoDBBigSegmentStore"
+          end
+
+          def get_metadata
+            key = @prefix + KEY_METADATA
+            data = @client.get_item(
+              table_name: @table_name,
+              key: {
+                PARTITION_KEY => key,
+                SORT_KEY => key,
+              }
+            )
+            timestamp = data.item && data.item[ATTR_SYNC_TIME] ?
+              data.item[ATTR_SYNC_TIME] : nil
+            LaunchDarkly::Interfaces::BigSegmentStoreMetadata.new(timestamp)
+          end
+
+          def get_membership(context_hash)
+            data = @client.get_item(
+              table_name: @table_name,
+              key: {
+                PARTITION_KEY => @prefix + KEY_CONTEXT_DATA,
+                SORT_KEY => context_hash,
+              })
+            return nil unless data.item
+            excluded_refs = data.item[ATTR_EXCLUDED] || []
+            included_refs = data.item[ATTR_INCLUDED] || []
+            if excluded_refs.empty? && included_refs.empty?
+              nil
+            else
+              membership = {}
+              excluded_refs.each { |ref| membership[ref] = false }
+              included_refs.each { |ref| membership[ref] = true }
+              membership
+            end
+          end
+        end
+
         class DynamoDBUtil
           #
           # Calls client.batch_write_item as many times as necessary to submit all of the given requests.

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

@@ -0,0 +1,212 @@
+require 'ldclient-rb/in_memory_store'
+require 'ldclient-rb/util'
+
+require 'concurrent/atomics'
+require 'json'
+require 'yaml'
+require 'pathname'
+
+module LaunchDarkly
+  module Impl
+    module Integrations
+      class FileDataSourceImpl
+        # To avoid pulling in 'listen' and its transitive dependencies for people who aren't using the
+        # file data source or who don't need auto-updating, we only enable auto-update if the 'listen'
+        # gem has been provided by the host app.
+        @@have_listen = false
+        begin
+          require 'listen'
+          @@have_listen = true
+        rescue LoadError
+        end
+
+        def initialize(feature_store, logger, options={})
+          @feature_store = feature_store
+          @logger = logger
+          @paths = options[:paths] || []
+          if @paths.is_a? String
+            @paths = [ @paths ]
+          end
+          @auto_update = options[:auto_update]
+          if @auto_update && @@have_listen && !options[:force_polling] # force_polling is used only for tests
+            # We have seen unreliable behavior in the 'listen' gem in JRuby 9.1 (https://github.com/guard/listen/issues/449).
+            # Therefore, on that platform we'll fall back to file polling instead.
+            if defined?(JRUBY_VERSION) && JRUBY_VERSION.start_with?("9.1.")
+              @use_listen = false
+            else
+              @use_listen = true
+            end
+          end
+          @poll_interval = options[:poll_interval] || 1
+          @initialized = Concurrent::AtomicBoolean.new(false)
+          @ready = Concurrent::Event.new
+        end
+
+        def initialized?
+          @initialized.value
+        end
+
+        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
+
+          load_all
+
+          if @auto_update
+            # If we're going to watch files, then the start event will be set the first time we get
+            # a successful load.
+            @listener = start_listener
+          end
+
+          ready
+        end
+
+        def stop
+          @listener.stop unless @listener.nil?
+        end
+
+        private
+
+        def load_all
+          all_data = {
+            FEATURES => {},
+            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)
+              return
+            end
+          end
+          @feature_store.init(all_data)
+          @initialized.make_true
+        end
+
+        def load_file(path, all_data)
+          parsed = parse_content(IO.read(path))
+          (parsed[:flags] || {}).each do |key, flag|
+            add_item(all_data, FEATURES, flag)
+          end
+          (parsed[:flagValues] || {}).each do |key, value|
+            add_item(all_data, FEATURES, make_flag_with_value(key.to_s, value))
+          end
+          (parsed[:segments] || {}).each do |key, segment|
+            add_item(all_data, SEGMENTS, segment)
+          end
+        end
+
+        def parse_content(content)
+          # We can use the Ruby YAML parser for both YAML and JSON (JSON is a subset of YAML and while
+          # not all YAML parsers handle it correctly, we have verified that the Ruby one does, at least
+          # for all the samples of actual flag data that we've tested).
+          symbolize_all_keys(YAML.safe_load(content))
+        end
+
+        def symbolize_all_keys(value)
+          # This is necessary because YAML.load doesn't have an option for parsing keys as symbols, and
+          # the SDK expects all objects to be formatted that way.
+          if value.is_a?(Hash)
+            value.map{ |k, v| [k.to_sym, symbolize_all_keys(v)] }.to_h
+          elsif value.is_a?(Array)
+            value.map{ |v| symbolize_all_keys(v) }
+          else
+            value
+          end
+        end
+
+        def add_item(all_data, kind, item)
+          items = all_data[kind]
+          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
+          unless items[key].nil?
+            raise ArgumentError, "#{kind[:namespace]} key \"#{item[:key]}\" was used more than once"
+          end
+          items[key] = Model.deserialize(kind, item)
+        end
+
+        def make_flag_with_value(key, value)
+          {
+            key: key,
+            on: true,
+            fallthrough: { variation: 0 },
+            variations: [ value ],
+          }
+        end
+
+        def start_listener
+          resolved_paths = @paths.map { |p| Pathname.new(File.absolute_path(p)).realpath.to_s }
+          if @use_listen
+            start_listener_with_listen_gem(resolved_paths)
+          else
+            FileDataSourcePoller.new(resolved_paths, @poll_interval, self.method(:load_all), @logger)
+          end
+        end
+
+        def start_listener_with_listen_gem(resolved_paths)
+          path_set = resolved_paths.to_set
+          dir_paths = resolved_paths.map{ |p| File.dirname(p) }.uniq
+          opts = { latency: @poll_interval }
+          l = Listen.to(*dir_paths, opts) do |modified, added, removed|
+            paths = modified + added + removed
+            if paths.any? { |p| path_set.include?(p) }
+              load_all
+            end
+          end
+          l.start
+          l
+        end
+
+        #
+        # Used internally by FileDataSource to track data file changes if the 'listen' gem is not available.
+        #
+        class FileDataSourcePoller
+          def initialize(resolved_paths, interval, reloader, logger)
+            @stopped = Concurrent::AtomicBoolean.new(false)
+            get_file_times = Proc.new do
+              ret = {}
+              resolved_paths.each do |path|
+                begin
+                  ret[path] = File.mtime(path)
+                rescue Errno::ENOENT
+                  ret[path] = nil
+                end
+              end
+              ret
+            end
+            last_times = get_file_times.call
+            @thread = Thread.new do
+              while true
+                sleep interval
+                break if @stopped.value
+                begin
+                  new_times = get_file_times.call
+                  changed = false
+                  last_times.each do |path, old_time|
+                    new_time = new_times[path]
+                    if !new_time.nil? && new_time != old_time
+                      changed = true
+                      break
+                    end
+                  end
+                  reloader.call if changed
+                rescue => exn
+                  LaunchDarkly::Util.log_exception(logger, "Unexpected exception in FileDataSourcePoller", exn)
+                end
+              end
+            end
+          end
+
+          def stop
+            @stopped.make_true
+            @thread.run  # wakes it up if it's sleeping
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -6,9 +6,87 @@ module LaunchDarkly
     module Integrations
       module Redis
         #
-        # Internal implementation of the Redis feature store, intended to be used with CachingStoreWrapper.
+        # 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 RedisFeatureStoreCore
+        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
+
+          #
+          # 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"
             require "connection_pool"
@@ -18,35 +96,68 @@ module LaunchDarkly
           end
 
           def initialize(opts)
-            if !REDIS_ENABLED
-              raise RuntimeError.new("can't use Redis feature store because one of these gems is missing: redis, connection_pool")
+            unless REDIS_ENABLED
+              raise RuntimeError.new("can't use #{description} because one of these gems is missing: redis, connection_pool")
             end
 
-            @redis_opts = opts[:redis_opts] || Hash.new
-            if opts[:redis_url]
-              @redis_opts[:url] = opts[:redis_url]
-            end
-            if !@redis_opts.include?(:url)
-              @redis_opts[:url] = LaunchDarkly::Integrations::Redis::default_redis_url
-            end
-            max_connections = opts[:max_connections] || 16
-            @pool = opts[:pool] || ConnectionPool.new(size: max_connections) do
-              ::Redis.new(@redis_opts)
-            end
+            @pool = create_redis_pool(opts)
+
             # shutdown pool on close unless the client passed a custom pool and specified not to shutdown
             @pool_shutdown_on_close = (!opts[:pool] || opts.fetch(:pool_shutdown_on_close, true))
+
             @prefix = opts[:prefix] || LaunchDarkly::Integrations::Redis::default_prefix
             @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("RedisFeatureStore: using Redis instance at #{redis.connection[:host]}:#{redis.connection[:port]} \
-      and prefix: #{@prefix}")
+              @logger.info("#{description}: using Redis instance at #{redis.connection[:host]}:#{redis.connection[:port]} and prefix: #{@prefix}")
             end
           end
 
+          def stop
+            if @stopped.make_true
+              return unless @pool_shutdown_on_close
+              @pool.shutdown { |redis| redis.close }
+            end
+          end
+
+          protected def description
+            "Redis"
+          end
+
+          protected def with_connection
+            @pool.with { |redis| yield(redis) }
+          end
+
+          private def create_redis_pool(opts)
+            redis_opts = opts[:redis_opts] ? opts[:redis_opts].clone : Hash.new
+            if opts[:redis_url]
+              redis_opts[:url] = opts[:redis_url]
+            end
+            unless redis_opts.include?(:url)
+              redis_opts[:url] = LaunchDarkly::Integrations::Redis::default_redis_url
+            end
+            max_connections = opts[:max_connections] || 16
+            opts[:pool] || ConnectionPool.new(size: max_connections) { ::Redis.new(redis_opts) }
+          end
+        end
+
+        #
+        # Internal implementation of the Redis feature store, intended to be used with CachingStoreWrapper.
+        #
+        class RedisFeatureStoreCore < RedisStoreImplBase
+          def initialize(opts)
+            super(opts)
+
+            @test_hook = opts[:test_hook]  # used for unit tests, deliberately undocumented
+          end
+
+          def description
+            "RedisFeatureStore"
+          end
+
           def init_internal(all_data)
             count = 0
             with_connection do |redis|
@@ -103,8 +214,8 @@ module LaunchDarkly
                   else
                     final_item = old_item
                     action = new_item[:deleted] ? "delete" : "update"
-                    @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]}" }
+                    # 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
                 end
@@ -117,17 +228,10 @@ module LaunchDarkly
             with_connection { |redis| redis.exists?(inited_key) }
           end
 
-          def stop
-            if @stopped.make_true
-              return unless @pool_shutdown_on_close
-              @pool.shutdown { |redis| redis.close }
-            end
-          end
-
           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)
@@ -142,14 +246,43 @@ module LaunchDarkly
             @prefix + ":$inited"
           end
 
-          def with_connection
-            @pool.with { |redis| yield(redis) }
-          end
-
           def get_redis(redis, kind, key)
             Model.deserialize(kind, redis.hget(items_key(kind), key))
           end
         end
+
+        #
+        # Internal implementation of the Redis big segment store.
+        #
+        class RedisBigSegmentStore < RedisStoreImplBase
+          KEY_LAST_UP_TO_DATE = ':big_segments_synchronized_on'
+          KEY_CONTEXT_INCLUDE = ':big_segment_include:'
+          KEY_CONTEXT_EXCLUDE = ':big_segment_exclude:'
+
+          def description
+            "RedisBigSegmentStore"
+          end
+
+          def get_metadata
+            value = with_connection { |redis| redis.get(@prefix + KEY_LAST_UP_TO_DATE) }
+            Interfaces::BigSegmentStoreMetadata.new(value.nil? ? nil : value.to_i)
+          end
+
+          def get_membership(context_hash)
+            with_connection do |redis|
+              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
+                membership = {}
+                excluded_refs.each { |ref| membership[ref] = false }
+                included_refs.each { |ref| membership[ref] = true }
+                membership
+              end
+            end
+          end
+        end
       end
     end
   end