launchdarkly-server-sdk 8.8.3-java

data/lib/ldclient-rb/impl/migrations/tracker.rb

@@ -0,0 +1,136 @@
+require "set"
+require "ldclient-rb/impl/sampler"
+require "logger"
+
+module LaunchDarkly
+  module Impl
+    module Migrations
+      class OpTracker
+        include LaunchDarkly::Interfaces::Migrations::OpTracker
+
+        #
+        # @param logger [Logger] logger
+        # @param key [string] key
+        # @param flag [LaunchDarkly::Impl::Model::FeatureFlag] flag
+        # @param context [LaunchDarkly::LDContext] context
+        # @param detail [LaunchDarkly::EvaluationDetail] detail
+        # @param default_stage [Symbol] default_stage
+        #
+        def initialize(logger, key, flag, context, detail, default_stage)
+          @logger = logger
+          @key = key
+          @flag = flag
+          @context = context
+          @detail = detail
+          @default_stage = default_stage
+          @sampler = LaunchDarkly::Impl::Sampler.new(Random.new)
+
+          @mutex = Mutex.new
+
+          # @type [Symbol, nil]
+          @operation = nil
+
+          # @type [Set<Symbol>]
+          @invoked = Set.new
+          # @type [Boolean, nil]
+          @consistent = nil
+
+          # @type [Int]
+          @consistent_ratio = @flag&.migration_settings&.check_ratio
+          @consistent_ratio = 1 if @consistent_ratio.nil?
+
+          # @type [Set<Symbol>]
+          @errors = Set.new
+          # @type [Hash<Symbol, Float>]
+          @latencies = Hash.new
+        end
+
+        def operation(operation)
+          return unless LaunchDarkly::Migrations::VALID_OPERATIONS.include? operation
+
+          @mutex.synchronize do
+            @operation = operation
+          end
+        end
+
+        def invoked(origin)
+          return unless LaunchDarkly::Migrations::VALID_ORIGINS.include? origin
+
+          @mutex.synchronize do
+            @invoked.add(origin)
+          end
+        end
+
+        def consistent(is_consistent)
+          @mutex.synchronize do
+            if @sampler.sample(@consistent_ratio)
+              begin
+                @consistent = is_consistent.call
+              rescue => e
+                LaunchDarkly::Util.log_exception(@logger, "Exception raised during consistency check; failed to record measurement", e)
+              end
+            end
+          end
+        end
+
+        def error(origin)
+          return unless LaunchDarkly::Migrations::VALID_ORIGINS.include? origin
+
+          @mutex.synchronize do
+            @errors.add(origin)
+          end
+        end
+
+        def latency(origin, duration)
+          return unless LaunchDarkly::Migrations::VALID_ORIGINS.include? origin
+          return unless duration.is_a? Numeric
+          return if duration < 0
+
+          @mutex.synchronize do
+            @latencies[origin] = duration
+          end
+        end
+
+        def build
+          @mutex.synchronize do
+            return "operation cannot contain an empty key" if @key.empty?
+            return "operation not provided" if @operation.nil?
+            return "no origins were invoked" if @invoked.empty?
+            return "provided context was invalid" unless @context.valid?
+
+            result = check_invoked_consistency
+            return result unless result == true
+
+            LaunchDarkly::Impl::MigrationOpEvent.new(
+              LaunchDarkly::Impl::Util.current_time_millis,
+              @context,
+              @key,
+              @flag,
+              @operation,
+              @default_stage,
+              @detail,
+              @invoked,
+              @consistent,
+              @consistent_ratio,
+              @errors,
+              @latencies
+            )
+          end
+        end
+
+        private def check_invoked_consistency
+          LaunchDarkly::Migrations::VALID_ORIGINS.each do |origin|
+            next if @invoked.include? origin
+
+            return "provided latency for origin '#{origin}' without recording invocation" if @latencies.include? origin
+            return "provided error for origin '#{origin}' without recording invocation" if @errors.include? origin
+          end
+
+          return "provided consistency without recording both invocations" if !@consistent.nil? && @invoked.size != 2
+
+          true
+        end
+      end
+    end
+  end
+end

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,254 @@
+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
+          migration_settings = data[:migration] || {}
+          @migration_settings = MigrationSettings.new(migration_settings[:checkRatio])
+          @sampling_ratio = data[:samplingRatio]
+          @exclude_from_summaries = !!data[:excludeFromSummaries]
+          @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)
+          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 [MigrationSettings, nil]
+        attr_reader :migration_settings
+        # @return [Integer, nil]
+        attr_reader :sampling_ratio
+        # @return [Boolean, nil]
+        attr_reader :exclude_from_summaries
+        # @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)
+          @data = data
+          @key = data[:key]
+          @variation = data[:variation]
+          @failure_result = EvaluatorHelpers.evaluation_detail_for_off_variation(flag,
+            EvaluationReason::prerequisite_failed(@key))
+        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 MigrationSettings
+        #
+        # @param check_ratio [Int, nil]
+        #
+        def initialize(check_ratio)
+          @check_ratio = check_ratio
+        end
+
+        # @return [Integer, nil]
+        attr_reader :check_ratio
+      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

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

@@ -0,0 +1,64 @@
+require "ldclient-rb/impl/evaluator_helpers"
+
+module LaunchDarkly
+  module Impl
+    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
+      # "in experiment" state.
+      #
+      class EvalResultsForSingleVariation
+        def initialize(value, variation_index, regular_reason, in_experiment_reason = nil)
+          @regular_result = EvaluationDetail.new(value, variation_index, regular_reason)
+          @in_experiment_result = in_experiment_reason ?
+            EvaluationDetail.new(value, variation_index, in_experiment_reason) :
+            @regular_result
+        end
+
+        # @param in_experiment [Boolean] indicates whether we want the result to include
+        #   "inExperiment: true" in the reason or not
+        # @return [LaunchDarkly::EvaluationDetail]
+        def get_result(in_experiment = false)
+          in_experiment ? @in_experiment_result : @regular_result
+        end
+      end
+
+      #
+      # Container for a set of precomputed results, one for each possible flag variation.
+      #
+      class EvalResultFactoryMultiVariations
+        def initialize(variation_factories)
+          @factories = variation_factories
+        end
+
+        # @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
+
+      class Preprocessor
+        # @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|
+            factories << EvalResultsForSingleVariation.new(vars[index], index, regular_reason, in_experiment_reason)
+          end
+          EvalResultFactoryMultiVariations.new(factories)
+        end
+      end
+    end
+  end
+end

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