launchdarkly-server-sdk 6.4.0 → 7.0.1

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}\"")
           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.
         #
@@ -83,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 } })
@@ -123,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
@@ -159,7 +159,7 @@ module LaunchDarkly
           def make_keys_hash(namespace, key)
             {
               PARTITION_KEY => namespace,
-              SORT_KEY => key
+              SORT_KEY => key,
             }
           end
 
@@ -170,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
 
@@ -190,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)
@@ -210,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
 
@@ -223,11 +223,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 +243,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 +251,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

@@ -48,7 +48,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 +63,9 @@ module LaunchDarkly
 
           ready
         end
-        
+
         def stop
-          @listener.stop if !@listener.nil?
+          @listener.stop unless @listener.nil?
         end
 
         private
@@ -73,7 +73,7 @@ module LaunchDarkly
         def load_all
           all_data = {
             FEATURES => {},
-            SEGMENTS => {}
+            SEGMENTS => {},
           }
           @paths.each do |path|
             begin
@@ -121,12 +121,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 +134,7 @@ module LaunchDarkly
             key: key,
             on: true,
             fallthrough: { variation: 0 },
-            variations: [ value ]
+            variations: [ value ],
           }
         end
 

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

@@ -5,6 +5,87 @@ 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
+
+          #
+          # 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 +96,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 +109,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 +136,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
 
@@ -135,6 +214,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 +231,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 +256,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 +268,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

data/lib/ldclient-rb/impl/model/clause.rb

@@ -0,0 +1,45 @@
+require "ldclient-rb/reference"
+
+
+# See serialization.rb for implementation notes on the data model classes.
+
+module LaunchDarkly
+  module Impl
+    module Model
+      class Clause
+        def initialize(data, errors_out = nil)
+          @data = data
+          @context_kind = data[:contextKind]
+          @op = data[:op].to_sym
+          if @op == :segmentMatch
+            @attribute = nil
+          else
+            @attribute = (@context_kind.nil? || @context_kind.empty?) ? Reference.create_literal(data[:attribute]) : Reference.create(data[:attribute])
+            unless errors_out.nil? || @attribute.error.nil?
+              errors_out << "clause has invalid attribute: #{@attribute.error}"
+            end
+          end
+          @values = data[:values] || []
+          @negate = !!data[:negate]
+        end
+
+        # @return [Hash]
+        attr_reader :data
+        # @return [String|nil]
+        attr_reader :context_kind
+        # @return [LaunchDarkly::Reference]
+        attr_reader :attribute
+        # @return [Symbol]
+        attr_reader :op
+        # @return [Array]
+        attr_reader :values
+        # @return [Boolean]
+        attr_reader :negate
+
+        def as_json
+          @data
+        end
+      end
+    end
+  end
+end

data/lib/ldclient-rb/impl/model/feature_flag.rb

@@ -0,0 +1,232 @@
+require "ldclient-rb/impl/evaluator_helpers"
+require "ldclient-rb/impl/model/clause"
+require "set"
+
+# See serialization.rb for implementation notes on the data model classes.
+
+def check_variation_range(flag, errors_out, variation, description)
+  unless flag.nil? || errors_out.nil? || variation.nil?
+    if variation < 0 || variation >= flag.variations.length
+      errors_out << "#{description} has invalid variation index"
+    end
+  end
+end
+
+module LaunchDarkly
+  module Impl
+    module Model
+      class FeatureFlag
+        # @param data [Hash]
+        # @param logger [Logger|nil]
+        def initialize(data, logger = nil)
+          raise ArgumentError, "expected hash but got #{data.class}" unless data.is_a?(Hash)
+          errors = []
+          @data = data
+          @key = data[:key]
+          @version = data[:version]
+          @deleted = !!data[:deleted]
+          return if @deleted
+          @variations = data[:variations] || []
+          @on = !!data[:on]
+          fallthrough = data[:fallthrough] || {}
+          @fallthrough = VariationOrRollout.new(fallthrough[:variation], fallthrough[:rollout], self, errors, "fallthrough")
+          @off_variation = data[:offVariation]
+          check_variation_range(self, errors, @off_variation, "off variation")
+          @prerequisites = (data[:prerequisites] || []).map do |prereq_data|
+            Prerequisite.new(prereq_data, self, errors)
+          end
+          @targets = (data[:targets] || []).map do |target_data|
+            Target.new(target_data, self, errors)
+          end
+          @context_targets = (data[:contextTargets] || []).map do |target_data|
+            Target.new(target_data, self, errors)
+          end
+          @rules = (data[:rules] || []).map.with_index do |rule_data, index|
+            FlagRule.new(rule_data, index, self, errors)
+          end
+          @salt = data[:salt]
+          @off_result = EvaluatorHelpers.evaluation_detail_for_off_variation(self, EvaluationReason::off)
+          @fallthrough_results = Preprocessor.precompute_multi_variation_results(self,
+              EvaluationReason::fallthrough(false), EvaluationReason::fallthrough(true))
+          unless logger.nil?
+            errors.each do |message|
+              logger.error("[LDClient] Data inconsistency in feature flag \"#{@key}\": #{message}")
+            end
+          end
+        end
+
+        # @return [Hash]
+        attr_reader :data
+        # @return [String]
+        attr_reader :key
+        # @return [Integer]
+        attr_reader :version
+        # @return [Boolean]
+        attr_reader :deleted
+        # @return [Array]
+        attr_reader :variations
+        # @return [Boolean]
+        attr_reader :on
+        # @return [Integer|nil]
+        attr_reader :off_variation
+        # @return [LaunchDarkly::Impl::Model::VariationOrRollout]
+        attr_reader :fallthrough
+        # @return [LaunchDarkly::EvaluationDetail]
+        attr_reader :off_result
+        # @return [LaunchDarkly::Impl::Model::EvalResultFactoryMultiVariations]
+        attr_reader :fallthrough_results
+        # @return [Array<LaunchDarkly::Impl::Model::Prerequisite>]
+        attr_reader :prerequisites
+        # @return [Array<LaunchDarkly::Impl::Model::Target>]
+        attr_reader :targets
+        # @return [Array<LaunchDarkly::Impl::Model::Target>]
+        attr_reader :context_targets
+        # @return [Array<LaunchDarkly::Impl::Model::FlagRule>]
+        attr_reader :rules
+        # @return [String]
+        attr_reader :salt
+
+        # This method allows us to read properties of the object as if it's just a hash. Currently this is
+        # necessary because some data store logic is still written to expect hashes; we can remove it once
+        # we migrate entirely to using attributes of the class.
+        def [](key)
+          @data[key]
+        end
+
+        def ==(other)
+          other.is_a?(FeatureFlag) && other.data == self.data
+        end
+
+        def as_json(*) # parameter is unused, but may be passed if we're using the json gem
+          @data
+        end
+
+        # Same as as_json, but converts the JSON structure into a string.
+        def to_json(*a)
+          as_json.to_json(a)
+        end
+      end
+
+      class Prerequisite
+        def initialize(data, flag, errors_out = nil)
+          @data = data
+          @key = data[:key]
+          @variation = data[:variation]
+          @failure_result = EvaluatorHelpers.evaluation_detail_for_off_variation(flag,
+            EvaluationReason::prerequisite_failed(@key))
+          check_variation_range(flag, errors_out, @variation, "prerequisite")
+        end
+
+        # @return [Hash]
+        attr_reader :data
+        # @return [String]
+        attr_reader :key
+        # @return [Integer]
+        attr_reader :variation
+        # @return [LaunchDarkly::EvaluationDetail]
+        attr_reader :failure_result
+      end
+
+      class Target
+        def initialize(data, flag, errors_out = nil)
+          @kind = data[:contextKind] || LDContext::KIND_DEFAULT
+          @data = data
+          @values = Set.new(data[:values] || [])
+          @variation = data[:variation]
+          @match_result = EvaluatorHelpers.evaluation_detail_for_variation(flag,
+            data[:variation], EvaluationReason::target_match)
+          check_variation_range(flag, errors_out, @variation, "target")
+        end
+
+        # @return [String]
+        attr_reader :kind
+        # @return [Hash]
+        attr_reader :data
+        # @return [Set]
+        attr_reader :values
+        # @return [Integer]
+        attr_reader :variation
+        # @return [LaunchDarkly::EvaluationDetail]
+        attr_reader :match_result
+      end
+
+      class FlagRule
+        def initialize(data, rule_index, flag, errors_out = nil)
+          @data = data
+          @clauses = (data[:clauses] || []).map do |clause_data|
+            Clause.new(clause_data, errors_out)
+          end
+          @variation_or_rollout = VariationOrRollout.new(data[:variation], data[:rollout], flag, errors_out, 'rule')
+          rule_id = data[:id]
+          match_reason = EvaluationReason::rule_match(rule_index, rule_id)
+          match_reason_in_experiment = EvaluationReason::rule_match(rule_index, rule_id, true)
+          @match_results = Preprocessor.precompute_multi_variation_results(flag, match_reason, match_reason_in_experiment)
+        end
+
+        # @return [Hash]
+        attr_reader :data
+        # @return [Array<LaunchDarkly::Impl::Model::Clause>]
+        attr_reader :clauses
+        # @return [LaunchDarkly::Impl::Model::EvalResultFactoryMultiVariations]
+        attr_reader :match_results
+        # @return [LaunchDarkly::Impl::Model::VariationOrRollout]
+        attr_reader :variation_or_rollout
+      end
+
+      class VariationOrRollout
+        def initialize(variation, rollout_data, flag = nil, errors_out = nil, description = nil)
+          @variation = variation
+          check_variation_range(flag, errors_out, variation, description)
+          @rollout = rollout_data.nil? ? nil : Rollout.new(rollout_data, flag, errors_out, description)
+        end
+
+        # @return [Integer|nil]
+        attr_reader :variation
+        # @return [Rollout|nil] currently we do not have a model class for the rollout
+        attr_reader :rollout
+      end
+
+      class Rollout
+        def initialize(data, flag = nil, errors_out = nil, description = nil)
+          @context_kind = data[:contextKind]
+          @variations = (data[:variations] || []).map { |v| WeightedVariation.new(v, flag, errors_out, description) }
+          @bucket_by = data[:bucketBy]
+          @kind = data[:kind]
+          @is_experiment = @kind == "experiment"
+          @seed = data[:seed]
+        end
+
+        # @return [String|nil]
+        attr_reader :context_kind
+        # @return [Array<WeightedVariation>]
+        attr_reader :variations
+        # @return [String|nil]
+        attr_reader :bucket_by
+        # @return [String|nil]
+        attr_reader :kind
+        # @return [Boolean]
+        attr_reader :is_experiment
+        # @return [Integer|nil]
+        attr_reader :seed
+      end
+
+      class WeightedVariation
+        def initialize(data, flag = nil, errors_out = nil, description = nil)
+          @variation = data[:variation]
+          @weight = data[:weight]
+          @untracked = !!data[:untracked]
+          check_variation_range(flag, errors_out, @variation, description)
+        end
+
+        # @return [Integer]
+        attr_reader :variation
+        # @return [Integer]
+        attr_reader :weight
+        # @return [Boolean]
+        attr_reader :untracked
+      end
+
+      # Clause is defined in its own file because clauses are used by both flags and segments
+    end
+  end
+end