launchdarkly-server-sdk 7.0.0 → 7.0.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: e189d76d654dbf73dc95e9cea758b81bc0df93d9012ebb6560d0994e6dff227c
-  data.tar.gz: fc8bdc8b9affee0e51ef233c217cfa4a3c7fbdbceb4694c38c5a2e90155205ed
+  metadata.gz: 75f53c22b8da0f6ef2ae0c387ec0e0fa7f421995a4325e984bbf45cb71d0104c
+  data.tar.gz: 85341f03930799add9de607e744c04ad1553582bcd275aa0a78169ee7a8fc9fa
 SHA512:
-  metadata.gz: 7fb89d48c3185f7019cd170f36f571b1ca2f7de130c624d6301fbfd30d46a0ae7a986494393ab290fa23b66511ce676b660533e1ad23d3a9e01fb037e20db6c4
-  data.tar.gz: 7e706747d2fcd1ab299a76eca7bf26908dbe97972b8c1ea74cfae6bc6aaffe866ddfc157b26675eb44fb22044c74efff88e7c5c4bf8dc0e75fa93dfe0ddbea8a
+  metadata.gz: 147b8b4ca65428dda6dda31bf1a09da6a982087c6fddf16dcd31aa8ae35c289c4aa4e9b2366c3605b9b9f4642c3c0fde20bad4fa0a207d3a92eba8a72b420bbc
+  data.tar.gz: b624f93ba0ada0244e3080713c99d7f45a78d3670d7a7b6c1fe5036aaf37396d3185e4286c7f6d739edef4b21ccfe503e91b65cce589963cb557cfd203ba9988

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

@@ -10,9 +10,9 @@ module LaunchDarkly
       # @param flag [LaunchDarkly::Impl::Model::FeatureFlag]
       # @param reason [LaunchDarkly::EvaluationReason]
       #
-      def self.evaluation_detail_for_off_variation(flag, reason, logger = nil)
+      def self.evaluation_detail_for_off_variation(flag, reason)
         index = flag.off_variation
-        index.nil? ? EvaluationDetail.new(nil, nil, reason) : evaluation_detail_for_variation(flag, index, reason, logger)
+        index.nil? ? EvaluationDetail.new(nil, nil, reason) : evaluation_detail_for_variation(flag, index, reason)
       end
 
       #
@@ -20,11 +20,11 @@ module LaunchDarkly
       # @param index [Integer]
       # @param reason [LaunchDarkly::EvaluationReason]
       #
-      def self.evaluation_detail_for_variation(flag, index, reason, logger = nil)
+      def self.evaluation_detail_for_variation(flag, index, reason)
         vars = flag.variations
         if index < 0 || index >= vars.length
-          logger.error("[LDClient] Data inconsistency in feature flag \"#{flag.key}\": invalid variation index") unless logger.nil?
           EvaluationDetail.new(nil, nil, EvaluationReason::error(EvaluationReason::ERROR_MALFORMED_FLAG))
+          # This error condition has already been logged at the time we received the flag data - see model/feature_flag.rb
         else
           EvaluationDetail.new(vars[index], index, reason)
         end

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

@@ -1,3 +1,5 @@
+require "ldclient-rb/reference"
+
 
 # See serialization.rb for implementation notes on the data model classes.
 
@@ -5,14 +7,18 @@ module LaunchDarkly
   module Impl
     module Model
       class Clause
-        def initialize(data, logger)
+        def initialize(data, errors_out = nil)
           @data = data
           @context_kind = data[:contextKind]
-          @attribute = (@context_kind.nil? || @context_kind.empty?) ? Reference.create_literal(data[:attribute]) : Reference.create(data[:attribute])
-          unless logger.nil? || @attribute.error.nil?
-            logger.error("[LDClient] Data inconsistency in feature flag: #{@attribute.error}")
-          end
           @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

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

@@ -4,6 +4,14 @@ 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
@@ -12,6 +20,7 @@ module LaunchDarkly
         # @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]
@@ -20,24 +29,30 @@ module LaunchDarkly
           @variations = data[:variations] || []
           @on = !!data[:on]
           fallthrough = data[:fallthrough] || {}
-          @fallthrough = VariationOrRollout.new(fallthrough[:variation], fallthrough[:rollout])
+          @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, logger)
+            Prerequisite.new(prereq_data, self, errors)
           end
           @targets = (data[:targets] || []).map do |target_data|
-            Target.new(target_data, self, logger)
+            Target.new(target_data, self, errors)
           end
           @context_targets = (data[:contextTargets] || []).map do |target_data|
-            Target.new(target_data, self, logger)
+            Target.new(target_data, self, errors)
           end
           @rules = (data[:rules] || []).map.with_index do |rule_data, index|
-            FlagRule.new(rule_data, index, self, logger)
+            FlagRule.new(rule_data, index, self, errors)
           end
           @salt = data[:salt]
-          @off_result = EvaluatorHelpers.evaluation_detail_for_off_variation(self, EvaluationReason::off, logger)
+          @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]
@@ -93,12 +108,13 @@ module LaunchDarkly
       end
 
       class Prerequisite
-        def initialize(data, flag, logger)
+        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), logger)
+            EvaluationReason::prerequisite_failed(@key))
+          check_variation_range(flag, errors_out, @variation, "prerequisite")
         end
 
         # @return [Hash]
@@ -112,13 +128,14 @@ module LaunchDarkly
       end
 
       class Target
-        def initialize(data, flag, logger)
+        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, logger)
+            data[:variation], EvaluationReason::target_match)
+          check_variation_range(flag, errors_out, @variation, "target")
         end
 
         # @return [String]
@@ -134,12 +151,12 @@ module LaunchDarkly
       end
 
       class FlagRule
-        def initialize(data, rule_index, flag, logger)
+        def initialize(data, rule_index, flag, errors_out = nil)
           @data = data
           @clauses = (data[:clauses] || []).map do |clause_data|
-            Clause.new(clause_data, logger)
+            Clause.new(clause_data, errors_out)
           end
-          @variation_or_rollout = VariationOrRollout.new(data[:variation], data[:rollout])
+          @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)
@@ -157,9 +174,10 @@ module LaunchDarkly
       end
 
       class VariationOrRollout
-        def initialize(variation, rollout_data)
+        def initialize(variation, rollout_data, flag = nil, errors_out = nil, description = nil)
           @variation = variation
-          @rollout = rollout_data.nil? ? nil : Rollout.new(rollout_data)
+          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]
@@ -169,9 +187,9 @@ module LaunchDarkly
       end
 
       class Rollout
-        def initialize(data)
+        def initialize(data, flag = nil, errors_out = nil, description = nil)
           @context_kind = data[:contextKind]
-          @variations = (data[:variations] || []).map { |v| WeightedVariation.new(v) }
+          @variations = (data[:variations] || []).map { |v| WeightedVariation.new(v, flag, errors_out, description) }
           @bucket_by = data[:bucketBy]
           @kind = data[:kind]
           @is_experiment = @kind == "experiment"
@@ -193,10 +211,11 @@ module LaunchDarkly
       end
 
       class WeightedVariation
-        def initialize(data)
+        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]

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

@@ -12,6 +12,7 @@ module LaunchDarkly
         # @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]
@@ -26,12 +27,17 @@ module LaunchDarkly
             SegmentTarget.new(target_data)
           end
           @rules = (data[:rules] || []).map do |rule_data|
-            SegmentRule.new(rule_data, logger)
+            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]
@@ -98,10 +104,10 @@ module LaunchDarkly
       end
 
       class SegmentRule
-        def initialize(data, logger)
+        def initialize(data, errors_out = nil)
           @data = data
           @clauses = (data[:clauses] || []).map do |clause_data|
-            Clause.new(clause_data, logger)
+            Clause.new(clause_data, errors_out)
           end
           @weight = data[:weight]
           @bucket_by = data[:bucketBy]

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

@@ -37,7 +37,7 @@ module LaunchDarkly
       # @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 warnings if there are any data validation problems
+      # @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?

data/lib/ldclient-rb/version.rb

@@ -1,3 +1,3 @@
 module LaunchDarkly
-  VERSION = "7.0.0"
+  VERSION = "7.0.1"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: launchdarkly-server-sdk
 version: !ruby/object:Gem::Version
-  version: 7.0.0
+  version: 7.0.1
 platform: ruby
 authors:
 - LaunchDarkly
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2022-12-30 00:00:00.000000000 Z
+date: 2023-01-19 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: aws-sdk-dynamodb
@@ -338,7 +338,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.4.1
+rubygems_version: 3.4.4
 signing_key: 
 specification_version: 4
 summary: LaunchDarkly SDK for Ruby