launchdarkly-server-sdk 6.4.0 → 7.0.1

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

@@ -2,7 +2,7 @@ require "ldclient-rb/impl/evaluator_helpers"
 
 module LaunchDarkly
   module Impl
-    module DataModelPreprocessing
+    module Model
       #
       # Container for a precomputed result that includes a specific variation index and value, an
       # evaluation reason, and optionally an alternate evaluation reason that corresponds to the
@@ -18,7 +18,7 @@ module LaunchDarkly
 
         # @param in_experiment [Boolean] indicates whether we want the result to include
         #   "inExperiment: true" in the reason or not
-        # @return [EvaluationDetail]
+        # @return [LaunchDarkly::EvaluationDetail]
         def get_result(in_experiment = false)
           in_experiment ? @in_experiment_result : @regular_result
         end
@@ -35,135 +35,22 @@ module LaunchDarkly
         # @param index [Integer] the variation index
         # @param in_experiment [Boolean] indicates whether we want the result to include
         #   "inExperiment: true" in the reason or not
+        # @return [LaunchDarkly::EvaluationDetail]
         def for_variation(index, in_experiment)
           if index < 0 || index >= @factories.length
             EvaluationDetail.new(nil, nil, EvaluationReason.error(EvaluationReason::ERROR_MALFORMED_FLAG))
           else
             @factories[index].get_result(in_experiment)
           end
-        end 
-      end
-
-      # Base class for all of the preprocessed data classes we embed in our data model. Using this class
-      # ensures that none of its properties will be included in JSON representations. It also overrides
-      # == to say that it is always equal with another instance of the same class; equality tests on
-      # this class are only ever done in test code, and we want the contents of these classes to be
-      # ignored in test code unless we are looking at specific attributes.
-      class PreprocessedDataBase
-        def as_json(*)
-          nil
-        end
-        
-        def to_json(*a)
-          "null"
-        end
-
-        def ==(other)
-          other.class == self.class
-        end
-      end
-
-      class FlagPreprocessed < PreprocessedDataBase
-        def initialize(off_result, fallthrough_factory)
-          @off_result = off_result
-          @fallthrough_factory = fallthrough_factory
-        end
-
-        # @return [EvalResultsForSingleVariation]
-        attr_reader :off_result
-        # @return [EvalResultFactoryMultiVariations]
-        attr_reader :fallthrough_factory
-      end
-
-      class PrerequisitePreprocessed < PreprocessedDataBase
-        def initialize(failed_result)
-          @failed_result = failed_result
-        end
-
-        # @return [EvalResultsForSingleVariation]
-        attr_reader :failed_result
-      end
-
-      class TargetPreprocessed < PreprocessedDataBase
-        def initialize(match_result)
-          @match_result = match_result
         end
-
-        # @return [EvalResultsForSingleVariation]
-        attr_reader :match_result
-      end
-
-      class FlagRulePreprocessed < PreprocessedDataBase
-        def initialize(all_match_results)
-          @all_match_results = all_match_results
-        end
-
-        # @return [EvalResultsForSingleVariation]
-        attr_reader :all_match_results
       end
 
       class Preprocessor
-        def initialize(logger = nil)
-          @logger = logger
-        end
-
-        def preprocess_item!(kind, item)
-          if kind.eql? FEATURES
-            preprocess_flag!(item)
-          elsif kind.eql? SEGMENTS
-            preprocess_segment!(item)
-          end
-        end
-
-        def preprocess_all_items!(kind, items_map)
-          return items_map if !items_map
-          items_map.each do |key, item|
-            preprocess_item!(kind, item)
-          end
-        end
-
-        def preprocess_flag!(flag)
-          flag[:_preprocessed] = FlagPreprocessed.new(
-            EvaluatorHelpers.off_result(flag),
-            precompute_multi_variation_results(flag, EvaluationReason::fallthrough(false), EvaluationReason::fallthrough(true))
-          )
-          (flag[:prerequisites] || []).each do |prereq|
-            preprocess_prerequisite!(prereq, flag)
-          end
-          (flag[:targets] || []).each do |target|
-            preprocess_target!(target, flag)
-          end
-          rules = flag[:rules]
-          (rules || []).each_index do |index|
-            preprocess_flag_rule!(rules[index], index, flag)
-          end
-        end
-  
-        def preprocess_segment!(segment)
-          # nothing to do for segments currently
-        end
-  
-        private def preprocess_prerequisite!(prereq, flag)
-          prereq[:_preprocessed] = PrerequisitePreprocessed.new(
-            EvaluatorHelpers.prerequisite_failed_result(prereq, flag, @logger)
-          )
-        end
-  
-        private def preprocess_target!(target, flag)
-          target[:_preprocessed] = TargetPreprocessed.new(
-            EvaluatorHelpers.target_match_result(target, flag, @logger)
-          )
-        end
-  
-        private def preprocess_flag_rule!(rule, index, flag)
-          match_reason = EvaluationReason::rule_match(index, rule[:id])
-          match_reason_in_experiment = EvaluationReason::rule_match(index, rule[:id], true)
-          rule[:_preprocessed] = FlagRulePreprocessed.new(
-            precompute_multi_variation_results(flag, match_reason, match_reason_in_experiment)
-          )
-        end
-  
-        private def precompute_multi_variation_results(flag, regular_reason, in_experiment_reason)
+        # @param flag [LaunchDarkly::Impl::Model::FeatureFlag]
+        # @param regular_reason [LaunchDarkly::EvaluationReason]
+        # @param in_experiment_reason [LaunchDarkly::EvaluationReason]
+        # @return [EvalResultFactoryMultiVariations]
+        def self.precompute_multi_variation_results(flag, regular_reason, in_experiment_reason)
           factories = []
           vars = flag[:variations] || []
           vars.each_index do |index|

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

@@ -0,0 +1,132 @@
+require "ldclient-rb/impl/model/clause"
+require "ldclient-rb/impl/model/preprocessed_data"
+require "set"
+
+# See serialization.rb for implementation notes on the data model classes.
+
+module LaunchDarkly
+  module Impl
+    module Model
+      class Segment
+        # @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
+          @included = data[:included] || []
+          @excluded = data[:excluded] || []
+          @included_contexts = (data[:includedContexts] || []).map do |target_data|
+            SegmentTarget.new(target_data)
+          end
+          @excluded_contexts = (data[:excludedContexts] || []).map do |target_data|
+            SegmentTarget.new(target_data)
+          end
+          @rules = (data[:rules] || []).map do |rule_data|
+            SegmentRule.new(rule_data, errors)
+          end
+          @unbounded = !!data[:unbounded]
+          @unbounded_context_kind = data[:unboundedContextKind] || LDContext::KIND_DEFAULT
+          @generation = data[:generation]
+          @salt = data[:salt]
+          unless logger.nil?
+            errors.each do |message|
+              logger.error("[LDClient] Data inconsistency in segment \"#{@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<String>]
+        attr_reader :included
+        # @return [Array<String>]
+        attr_reader :excluded
+        # @return [Array<LaunchDarkly::Impl::Model::SegmentTarget>]
+        attr_reader :included_contexts
+        # @return [Array<LaunchDarkly::Impl::Model::SegmentTarget>]
+        attr_reader :excluded_contexts
+        # @return [Array<SegmentRule>]
+        attr_reader :rules
+        # @return [Boolean]
+        attr_reader :unbounded
+        # @return [String]
+        attr_reader :unbounded_context_kind
+        # @return [Integer|nil]
+        attr_reader :generation
+        # @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?(Segment) && 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 SegmentTarget
+        def initialize(data)
+          @data = data
+          @context_kind = data[:contextKind]
+          @values = Set.new(data[:values] || [])
+        end
+
+        # @return [Hash]
+        attr_reader :data
+        # @return [String]
+        attr_reader :context_kind
+        # @return [Set]
+        attr_reader :values
+      end
+
+      class SegmentRule
+        def initialize(data, errors_out = nil)
+          @data = data
+          @clauses = (data[:clauses] || []).map do |clause_data|
+            Clause.new(clause_data, errors_out)
+          end
+          @weight = data[:weight]
+          @bucket_by = data[:bucketBy]
+          @rollout_context_kind = data[:rolloutContextKind]
+        end
+
+        # @return [Hash]
+        attr_reader :data
+        # @return [Array<LaunchDarkly::Impl::Model::Clause>]
+        attr_reader :clauses
+        # @return [Integer|nil]
+        attr_reader :weight
+        # @return [String|nil]
+        attr_reader :bucket_by
+        # @return [String|nil]
+        attr_reader :rollout_context_kind
+      end
+
+      # Clause is defined in its own file because clauses are used by both flags and segments
+    end
+  end
+end

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

@@ -1,31 +1,71 @@
+require "ldclient-rb/impl/model/feature_flag"
 require "ldclient-rb/impl/model/preprocessed_data"
+require "ldclient-rb/impl/model/segment"
+
+# General implementation notes about the data model classes in LaunchDarkly::Impl::Model--
+#
+# As soon as we receive flag/segment JSON data from LaunchDarkly (or, read it from a database), we
+# transform it into the model classes FeatureFlag, Segment, etc. The constructor of each of these
+# classes takes a hash (the parsed JSON), and transforms it into an internal representation that
+# is more efficient for evaluations.
+#
+# Validation works as follows:
+# - A property value that is of the correct type, but is invalid for other reasons (for example,
+# if a flag rule refers to variation index 5, but there are only 2 variations in the flag), does
+# not prevent the flag from being parsed and stored. It does cause a warning to be logged, if a
+# logger was passed to the constructor.
+# - If a value is completely invalid for the schema, the constructor may throw an
+# exception, causing the whole data set to be rejected. This is consistent with the behavior of
+# the strongly-typed SDKs.
+#
+# Currently, the model classes also retain the original hash of the parsed JSON. This is because
+# we may need to re-serialize them to JSON, and building the JSON on the fly would be very
+# inefficient, so each model class has a to_json method that just returns the same Hash. If we
+# are able in the future to either use a custom streaming serializer, or pass the JSON data
+# straight through from LaunchDarkly to a database instead of re-serializing, we could stop
+# retaining this data.
 
 module LaunchDarkly
   module Impl
     module Model
       # Abstraction of deserializing a feature flag or segment that was read from a data store or
       # received from LaunchDarkly.
-      def self.deserialize(kind, json, logger = nil)
-        return nil if json.nil?
-        item = JSON.parse(json, symbolize_names: true)
-        DataModelPreprocessing::Preprocessor.new(logger).preprocess_item!(kind, item)
-        item
+      #
+      # SDK code outside of Impl::Model should use this method instead of calling the model class
+      # constructors directly, so as not to rely on implementation details.
+      #
+      # @param kind [Hash] normally either FEATURES or SEGMENTS
+      # @param input [object] a JSON string or a parsed hash (or a data model object, in which case
+      #  we'll just return the original object)
+      # @param logger [Logger|nil] logs errors if there are any data validation problems
+      # @return [Object] the flag or segment (or, for an unknown data kind, the data as a hash)
+      def self.deserialize(kind, input, logger = nil)
+        return nil if input.nil?
+        return input if !input.is_a?(String) && !input.is_a?(Hash)
+        data = input.is_a?(Hash) ? input : JSON.parse(input, symbolize_names: true)
+        case kind
+        when FEATURES
+          FeatureFlag.new(data, logger)
+        when SEGMENTS
+          Segment.new(data, logger)
+        else
+          data
+        end
       end
 
       # Abstraction of serializing a feature flag or segment that will be written to a data store.
-      # Currently we just call to_json.
+      # Currently we just call to_json, but SDK code outside of Impl::Model should use this method
+      # instead of to_json, so as not to rely on implementation details.
       def self.serialize(kind, item)
         item.to_json
       end
 
       # Translates a { flags: ..., segments: ... } object received from LaunchDarkly to the data store format.
       def self.make_all_store_data(received_data, logger = nil)
-        preprocessor = DataModelPreprocessing::Preprocessor.new(logger)
-        flags = received_data[:flags]
-        preprocessor.preprocess_all_items!(FEATURES, flags)
-        segments = received_data[:segments]
-        preprocessor.preprocess_all_items!(SEGMENTS, segments)
-        { FEATURES => flags, SEGMENTS => segments }
+        {
+          FEATURES => (received_data[:flags] || {}).transform_values { |data| FeatureFlag.new(data, logger) },
+          SEGMENTS => (received_data[:segments] || {}).transform_values { |data| Segment.new(data, logger) },
+        }
       end
     end
   end

data/lib/ldclient-rb/impl/repeating_task.rb

@@ -19,7 +19,7 @@ module LaunchDarkly
           if @start_delay
             sleep(@start_delay)
           end
-          while !@stopped.value do
+          until @stopped.value do
             started_at = Time.now
             begin
               @task.call

data/lib/ldclient-rb/impl/store_data_set_sorter.rb

@@ -33,7 +33,7 @@ module LaunchDarkly
         return input if dependency_fn.nil? || input.empty?
         remaining_items = input.clone
         items_out = {}
-        while !remaining_items.empty?
+        until remaining_items.empty?
           # pick a random item that hasn't been updated yet
           key, item = remaining_items.first
           self.add_with_dependencies_first(item, dependency_fn, remaining_items, items_out)
@@ -46,7 +46,7 @@ module LaunchDarkly
         remaining_items.delete(item_key)  # we won't need to visit this item again
         dependency_fn.call(item).each do |dep_key|
           dep_item = remaining_items[dep_key.to_sym]
-          self.add_with_dependencies_first(dep_item, dependency_fn, remaining_items, items_out) if !dep_item.nil?
+          self.add_with_dependencies_first(dep_item, dependency_fn, remaining_items, items_out) unless dep_item.nil?
         end
         items_out[item_key] = item
       end

data/lib/ldclient-rb/impl/unbounded_pool.rb

@@ -25,7 +25,7 @@ module LaunchDarkly
 
       def dispose_all
         @lock.synchronize {
-          @pool.map { |instance| @instance_destructor.call(instance) } if !@instance_destructor.nil?
+          @pool.map { |instance| @instance_destructor.call(instance) } unless @instance_destructor.nil?
           @pool.clear()
         }
       end

data/lib/ldclient-rb/impl/util.rb

@@ -1,7 +1,7 @@
 module LaunchDarkly
   module Impl
     module Util
-      def self.is_bool(aObject)
+      def self.bool?(aObject)
          [true,false].include? aObject
       end
 
@@ -56,7 +56,7 @@ module LaunchDarkly
           return ""
         end
 
-        if value.match(/[^a-zA-Z0-9._-]/)
+        if /[^a-zA-Z0-9._-]/.match?(value)
           logger.warn { "Value of application[#{name}] contained invalid characters and was discarded" }
           return ""
         end

data/lib/ldclient-rb/in_memory_store.rb

@@ -14,13 +14,13 @@ module LaunchDarkly
   FEATURES = {
     namespace: "features",
     priority: 1,  # that is, features should be stored after segments
-    get_dependency_keys: lambda { |flag| (flag[:prerequisites] || []).map { |p| p[:key] } }
+    get_dependency_keys: lambda { |flag| (flag[:prerequisites] || []).map { |p| p[:key] } },
   }.freeze
 
   # @private
   SEGMENTS = {
     namespace: "segments",
-    priority: 0
+    priority: 0,
   }.freeze
 
   #

data/lib/ldclient-rb/integrations/consul.rb

@@ -38,7 +38,7 @@ module LaunchDarkly
       #
       def self.new_feature_store(opts = {})
         core = LaunchDarkly::Impl::Integrations::Consul::ConsulFeatureStoreCore.new(opts)
-        return LaunchDarkly::Integrations::Util::CachingStoreWrapper.new(core, opts)
+        LaunchDarkly::Integrations::Util::CachingStoreWrapper.new(core, opts)
       end
     end
   end

data/lib/ldclient-rb/integrations/dynamodb.rb

@@ -54,7 +54,7 @@ module LaunchDarkly
       #
       # Creates a DynamoDB-backed Big Segment store.
       #
-      # Big Segments are a specific type of user segments. For more information, read the LaunchDarkly
+      # Big Segments are a specific type of segments. For more information, read the LaunchDarkly
       # documentation: https://docs.launchdarkly.com/home/users/big-segments
       #
       # To use this method, you must first install one of the AWS SDK gems: either `aws-sdk-dynamodb`, or

data/lib/ldclient-rb/integrations/file_data.rb

@@ -25,7 +25,7 @@ module LaunchDarkly
     #
     # - `flags`: Feature flag definitions.
     # - `flagValues`: Simplified feature flags that contain only a value.
-    # - `segments`: User segment definitions.
+    # - `segments`: Context segment definitions.
     #
     # The format of the data in `flags` and `segments` is defined by the LaunchDarkly application
     # and is subject to change. Rather than trying to construct these objects yourself, it is simpler
@@ -78,7 +78,7 @@ module LaunchDarkly
     # same flag key or segment key more than once, either in a single file or across multiple files.
     #
     # If the data source encounters any error in any file-- malformed content, a missing file, or a
-    # duplicate key-- it will not load flags from any of the files.      
+    # duplicate key-- it will not load flags from any of the files.
     #
     module FileData
       #
@@ -100,7 +100,7 @@ module LaunchDarkly
       # @return an object that can be stored in {Config#data_source}
       #
       def self.data_source(options={})
-        return lambda { |sdk_key, config|
+        lambda { |sdk_key, config|
           Impl::Integrations::FileDataSourceImpl.new(config.feature_store, config.logger, options) }
       end
     end

data/lib/ldclient-rb/integrations/redis.rb

@@ -1,4 +1,4 @@
-require "ldclient-rb/redis_store"  # eventually we will just refer to impl/integrations/redis_impl directly
+require "ldclient-rb/impl/integrations/redis_impl"
 
 module LaunchDarkly
   module Integrations
@@ -59,13 +59,13 @@ module LaunchDarkly
       # @return [LaunchDarkly::Interfaces::FeatureStore]  a feature store object
       #
       def self.new_feature_store(opts = {})
-        return RedisFeatureStore.new(opts)
+        LaunchDarkly::Impl::Integrations::Redis::RedisFeatureStore.new(opts)
       end
 
       #
       # Creates a Redis-backed Big Segment store.
       #
-      # Big Segments are a specific type of user segments. For more information, read the LaunchDarkly
+      # Big Segments are a specific type of segments. For more information, read the LaunchDarkly
       # documentation: https://docs.launchdarkly.com/home/users/big-segments
       #
       # To use this method, you must first have the `redis` and `connection-pool` gems installed. Then,
@@ -91,7 +91,7 @@ module LaunchDarkly
       # @return [LaunchDarkly::Interfaces::BigSegmentStore]  a Big Segment store object
       #
       def self.new_big_segment_store(opts)
-        return LaunchDarkly::Impl::Integrations::Redis::RedisBigSegmentStore.new(opts)
+        LaunchDarkly::Impl::Integrations::Redis::RedisBigSegmentStore.new(opts)
       end
     end
   end