launchdarkly-server-sdk 5.8.2 → 6.0.0

data/README.md

@@ -17,7 +17,7 @@ LaunchDarkly overview
 Supported Ruby versions
 -----------------------
 
-This version of the LaunchDarkly SDK has a minimum Ruby version of 2.2.6, or 9.1.6 for JRuby.
+This version of the LaunchDarkly SDK has a minimum Ruby version of 2.5.0, or 9.2.0 for JRuby.
 
 Getting started
 -----------
@@ -55,4 +55,4 @@ About LaunchDarkly
     * [docs.launchdarkly.com](https://docs.launchdarkly.com/  "LaunchDarkly Documentation") for our documentation and SDK reference guides
     * [apidocs.launchdarkly.com](https://apidocs.launchdarkly.com/  "LaunchDarkly API Documentation") for our API documentation
     * [blog.launchdarkly.com](https://blog.launchdarkly.com/  "LaunchDarkly Blog Documentation") for the latest product updates
-    * [Feature Flagging Guide](https://github.com/launchdarkly/featureflags/  "Feature Flagging Guide") for best practices and strategies
+    * [Feature Flagging Guide](https://github.com/launchdarkly/featureflags/  "Feature Flagging Guide") for best practices and strategies

data/azure-pipelines.yml

@@ -45,7 +45,7 @@ jobs:
           workingDirectory: $(System.DefaultWorkingDirectory)
           script: |
             ruby -v
-            gem install bundler -v 1.17.3
+            gem install bundler
             bundle install
             mkdir rspec
             bundle exec rspec --format progress --format RspecJunitFormatter -o ./rspec/rspec.xml spec

data/launchdarkly-server-sdk.gemspec

@@ -19,27 +19,27 @@ Gem::Specification.new do |spec|
   spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
   spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
   spec.require_paths = ["lib"]
+  spec.required_ruby_version = ">= 2.5.0"
 
-  spec.add_development_dependency "aws-sdk-dynamodb", "~> 1.18"
-  spec.add_development_dependency "bundler", "~> 1.17"
-  spec.add_development_dependency "rspec", "~> 3.2"
-  spec.add_development_dependency "diplomat", ">= 2.0.2"
-  spec.add_development_dependency "redis", "~> 3.3.5"
-  spec.add_development_dependency "connection_pool", ">= 2.1.2"
-  spec.add_development_dependency "rspec_junit_formatter", "~> 0.3.0"
-  spec.add_development_dependency "timecop", "~> 0.9.1"
-  spec.add_development_dependency "listen", "~> 3.0" # see file_data_source.rb
-  # these are transitive dependencies of listen and consul respectively
-  # we constrain them here to make sure the ruby 2.2, 2.3, and 2.4 CI
-  # cases all pass
-  spec.add_development_dependency "ffi", "<= 1.12" # >1.12 doesnt support ruby 2.2
-  spec.add_development_dependency "faraday", "~> 0.17" # >=0.18 doesnt support ruby 2.2
+  spec.add_development_dependency "aws-sdk-dynamodb", "~> 1.57"
+  spec.add_development_dependency "bundler", "~> 2.1"
+  spec.add_development_dependency "rspec", "~> 3.10"
+  spec.add_development_dependency "diplomat", "~> 2.4.2"
+  spec.add_development_dependency "redis", "~> 4.2"
+  spec.add_development_dependency "connection_pool", "~> 2.2.3"
+  spec.add_development_dependency "rspec_junit_formatter", "~> 0.4"
+  spec.add_development_dependency "timecop", "~> 0.9"
+  spec.add_development_dependency "listen", "~> 3.3" # see file_data_source.rb
+  spec.add_development_dependency "webrick", "~> 1.7"
+  # required by dynamodb
+  spec.add_development_dependency "oga", "~> 2.2"
 
   spec.add_runtime_dependency "semantic", "~> 1.6"
-  spec.add_runtime_dependency "concurrent-ruby", "~> 1.0"
-  spec.add_runtime_dependency "ld-eventsource", "1.0.3"
+  spec.add_runtime_dependency "concurrent-ruby", "~> 1.1"
+  spec.add_runtime_dependency "ld-eventsource", "~> 2.0"
 
   # lock json to 2.3.x as ruby libraries often remove
   # support for older ruby versions in minor releases
   spec.add_runtime_dependency "json", "~> 2.3.1"
+  spec.add_runtime_dependency "http", "~> 4.4.1"
 end

data/lib/ldclient-rb.rb

@@ -8,7 +8,6 @@ end
 require "ldclient-rb/version"
 require "ldclient-rb/interfaces"
 require "ldclient-rb/util"
-require "ldclient-rb/evaluation"
 require "ldclient-rb/flags_state"
 require "ldclient-rb/ldclient"
 require "ldclient-rb/cache_store"

data/lib/ldclient-rb/config.rb

@@ -15,7 +15,7 @@ module LaunchDarkly
     #
     # @param opts [Hash] the configuration options
     # @option opts [Logger] :logger See {#logger}.
-    # @option opts [String] :base_uri ("https://app.launchdarkly.com") See {#base_uri}.
+    # @option opts [String] :base_uri ("https://sdk.launchdarkly.com") See {#base_uri}.
     # @option opts [String] :stream_uri ("https://stream.launchdarkly.com") See {#stream_uri}.
     # @option opts [String] :events_uri ("https://events.launchdarkly.com") See {#events_uri}.
     # @option opts [Integer] :capacity (10000) See {#capacity}.
@@ -41,6 +41,7 @@ module LaunchDarkly
     # @option opts [Float] :diagnostic_recording_interval (900) See {#diagnostic_recording_interval}.
     # @option opts [String] :wrapper_name See {#wrapper_name}.
     # @option opts [String] :wrapper_version See {#wrapper_version}.
+    # @option opts [#open] :socket_factory See {#socket_factory}.
     #
     def initialize(opts = {})
       @base_uri = (opts[:base_uri] || Config.default_base_uri).chomp("/")
@@ -71,6 +72,7 @@ module LaunchDarkly
         opts[:diagnostic_recording_interval] : Config.default_diagnostic_recording_interval
       @wrapper_name = opts[:wrapper_name]
       @wrapper_version = opts[:wrapper_version]
+      @socket_factory = opts[:socket_factory]
     end
 
     #
@@ -305,6 +307,16 @@ module LaunchDarkly
     #
     attr_reader :wrapper_version
 
+    #
+    # The factory used to construct sockets for HTTP operations. The factory must
+    # provide the method `open(uri, timeout)`. The `open` method must return a
+    # connected stream that implements the `IO` class, such as a `TCPSocket`.
+    #
+    # Defaults to nil.
+    # @return [#open]
+    #
+    attr_reader :socket_factory
+
     #
     # The default LaunchDarkly client configuration. This configuration sets
     # reasonable defaults for most users.
@@ -324,10 +336,10 @@ module LaunchDarkly
 
     #
     # The default value for {#base_uri}.
-    # @return [String] "https://app.launchdarkly.com"
+    # @return [String] "https://sdk.launchdarkly.com"
     #
     def self.default_base_uri
-      "https://app.launchdarkly.com"
+      "https://sdk.launchdarkly.com"
     end
 
     #

data/lib/ldclient-rb/evaluation_detail.rb

@@ -0,0 +1,293 @@
+
+module LaunchDarkly
+# An object returned by {LDClient#variation_detail}, combining the result of a flag evaluation with
+  # an explanation of how it was calculated.
+  class EvaluationDetail
+    # Creates a new instance.
+    #
+    # @param value the result value of the flag evaluation; may be of any type
+    # @param variation_index [int|nil] the index of the value within the flag's list of variations, or
+    #  `nil` if the application default value was returned
+    # @param reason [EvaluationReason] an object describing the main factor that influenced the result
+    # @raise [ArgumentError] if `variation_index` or `reason` is not of the correct type
+    def initialize(value, variation_index, reason)
+      raise ArgumentError.new("variation_index must be a number") if !variation_index.nil? && !(variation_index.is_a? Numeric)
+      raise ArgumentError.new("reason must be an EvaluationReason") if !(reason.is_a? EvaluationReason)
+      @value = value
+      @variation_index = variation_index
+      @reason = reason
+    end
+
+    #
+    # The result of the flag evaluation. This will be either one of the flag's variations, or the
+    # default value that was passed to {LDClient#variation_detail}. It is the same as the return
+    # value of {LDClient#variation}.
+    #
+    # @return [Object]
+    #
+    attr_reader :value
+
+    #
+    # The index of the returned value within the flag's list of variations. The first variation is
+    # 0, the second is 1, etc. This is `nil` if the default value was returned.
+    #
+    # @return [int|nil]
+    #
+    attr_reader :variation_index
+
+    #
+    # An object describing the main factor that influenced the flag evaluation value.
+    #
+    # @return [EvaluationReason]
+    #
+    attr_reader :reason
+
+    #
+    # Tests whether the flag evaluation returned a default value. This is the same as checking
+    # whether {#variation_index} is nil.
+    #
+    # @return [Boolean]
+    #
+    def default_value?
+      variation_index.nil?
+    end
+
+    def ==(other)
+      @value == other.value && @variation_index == other.variation_index && @reason == other.reason
+    end
+  end
+
+  # Describes the reason that a flag evaluation produced a particular value. This is returned by
+  # methods such as {LDClient#variation_detail} as the `reason` property of an {EvaluationDetail}.
+  #
+  # The `kind` property is always defined, but other properties will have non-nil values only for
+  # certain values of `kind`. All properties are immutable.
+  #
+  # There is a standard JSON representation of evaluation reasons when they appear in analytics events.
+  # Use `as_json` or `to_json` to convert to this representation.
+  #
+  # Use factory methods such as {EvaluationReason#off} to obtain instances of this class.
+  class EvaluationReason
+    # Value for {#kind} indicating that the flag was off and therefore returned its configured off value.
+    OFF = :OFF
+    
+    # Value for {#kind} indicating that the flag was on but the user did not match any targets or rules.
+    FALLTHROUGH = :FALLTHROUGH
+    
+    # Value for {#kind} indicating that the user key was specifically targeted for this flag.
+    TARGET_MATCH = :TARGET_MATCH
+    
+    # Value for {#kind} indicating that the user matched one of the flag's rules.
+    RULE_MATCH = :RULE_MATCH
+    
+    # Value for {#kind} indicating that the flag was considered off because it had at least one
+    # prerequisite flag that either was off or did not return the desired variation.
+    PREREQUISITE_FAILED = :PREREQUISITE_FAILED
+    
+    # Value for {#kind} indicating that the flag could not be evaluated, e.g. because it does not exist
+    # or due to an unexpected error. In this case the result value will be the application default value
+    # that the caller passed to the client. Check {#error_kind} for more details on the problem.
+    ERROR = :ERROR
+
+    # Value for {#error_kind} indicating that the caller tried to evaluate a flag before the client had
+    # successfully initialized.
+    ERROR_CLIENT_NOT_READY = :CLIENT_NOT_READY
+
+    # Value for {#error_kind} indicating that the caller provided a flag key that did not match any known flag.
+    ERROR_FLAG_NOT_FOUND = :FLAG_NOT_FOUND
+
+    # Value for {#error_kind} indicating that there was an internal inconsistency in the flag data, e.g.
+    # a rule specified a nonexistent  variation. An error message will always be logged in this case.
+    ERROR_MALFORMED_FLAG = :MALFORMED_FLAG
+
+    # Value for {#error_kind} indicating that the caller passed `nil` for the user parameter, or the
+    # user lacked a key.
+    ERROR_USER_NOT_SPECIFIED = :USER_NOT_SPECIFIED
+
+    # Value for {#error_kind} indicating that an unexpected exception stopped flag evaluation. An error
+    # message will always be logged in this case.
+    ERROR_EXCEPTION = :EXCEPTION
+
+    # Indicates the general category of the reason. Will always be one of the class constants such
+    # as {#OFF}.
+    attr_reader :kind
+
+    # The index of the rule that was matched (0 for the first rule in the feature flag). If
+    # {#kind} is not {#RULE_MATCH}, this will be `nil`.
+    attr_reader :rule_index
+
+    # A unique string identifier for the matched rule, which will not change if other rules are added
+    # or deleted. If {#kind} is not {#RULE_MATCH}, this will be `nil`.
+    attr_reader :rule_id
+
+    # The key of the prerequisite flag that did not return the desired variation. If {#kind} is not
+    # {#PREREQUISITE_FAILED}, this will be `nil`.
+    attr_reader :prerequisite_key
+
+    # A value indicating the general category of error. This should be one of the class constants such
+    # as {#ERROR_FLAG_NOT_FOUND}. If {#kind} is not {#ERROR}, it will be `nil`.
+    attr_reader :error_kind
+
+    # Returns an instance whose {#kind} is {#OFF}.
+    # @return [EvaluationReason]
+    def self.off
+      @@off
+    end
+
+    # Returns an instance whose {#kind} is {#FALLTHROUGH}.
+    # @return [EvaluationReason]
+    def self.fallthrough
+      @@fallthrough
+    end
+
+    # Returns an instance whose {#kind} is {#TARGET_MATCH}.
+    # @return [EvaluationReason]
+    def self.target_match
+      @@target_match
+    end
+
+    # Returns an instance whose {#kind} is {#RULE_MATCH}.
+    #
+    # @param rule_index [Number] the index of the rule that was matched (0 for the first rule in
+    #   the feature flag)
+    # @param rule_id [String] unique string identifier for the matched rule
+    # @return [EvaluationReason]
+    # @raise [ArgumentError] if `rule_index` is not a number or `rule_id` is not a string
+    def self.rule_match(rule_index, rule_id)
+      raise ArgumentError.new("rule_index must be a number") if !(rule_index.is_a? Numeric)
+      raise ArgumentError.new("rule_id must be a string") if !rule_id.nil? && !(rule_id.is_a? String) # in test data, ID could be nil
+      new(:RULE_MATCH, rule_index, rule_id, nil, nil)
+    end
+
+    # Returns an instance whose {#kind} is {#PREREQUISITE_FAILED}.
+    #
+    # @param prerequisite_key [String] key of the prerequisite flag that did not return the desired variation
+    # @return [EvaluationReason]
+    # @raise [ArgumentError] if `prerequisite_key` is nil or not a string
+    def self.prerequisite_failed(prerequisite_key)
+      raise ArgumentError.new("prerequisite_key must be a string") if !(prerequisite_key.is_a? String)
+      new(:PREREQUISITE_FAILED, nil, nil, prerequisite_key, nil)
+    end
+
+    # Returns an instance whose {#kind} is {#ERROR}.
+    #
+    # @param error_kind [Symbol] value indicating the general category of error
+    # @return [EvaluationReason]
+    # @raise [ArgumentError] if `error_kind` is not a symbol
+    def self.error(error_kind)
+      raise ArgumentError.new("error_kind must be a symbol") if !(error_kind.is_a? Symbol)
+      e = @@error_instances[error_kind]
+      e.nil? ? make_error(error_kind) : e
+    end
+
+    def ==(other)
+      if other.is_a? EvaluationReason
+        @kind == other.kind && @rule_index == other.rule_index && @rule_id == other.rule_id &&
+          @prerequisite_key == other.prerequisite_key && @error_kind == other.error_kind
+      elsif other.is_a? Hash
+        @kind.to_s == other[:kind] && @rule_index == other[:ruleIndex] && @rule_id == other[:ruleId] &&
+          @prerequisite_key == other[:prerequisiteKey] &&
+          (other[:errorKind] == @error_kind.nil? ? nil : @error_kind.to_s)
+      end
+    end
+
+    # Equivalent to {#inspect}.
+    # @return [String]
+    def to_s
+      inspect
+    end
+
+    # Returns a concise string representation of the reason. Examples: `"FALLTHROUGH"`,
+    # `"ERROR(FLAG_NOT_FOUND)"`. The exact syntax is not guaranteed to remain the same; this is meant
+    # for debugging.
+    # @return [String]
+    def inspect
+      case @kind
+      when :RULE_MATCH
+        "RULE_MATCH(#{@rule_index},#{@rule_id})"
+      when :PREREQUISITE_FAILED
+        "PREREQUISITE_FAILED(#{@prerequisite_key})"
+      when :ERROR
+        "ERROR(#{@error_kind})"
+      else
+        @kind.to_s
+      end
+    end
+
+    # Returns a hash that can be used as a JSON representation of the reason, in the format used
+    # in LaunchDarkly analytics events.
+    # @return [Hash]
+    def as_json(*) # parameter is unused, but may be passed if we're using the json gem
+      # Note that this implementation is somewhat inefficient; it allocates a new hash every time.
+      # However, in normal usage the SDK only serializes reasons if 1. full event tracking is
+      # enabled for a flag and the application called variation_detail, or 2. experimentation is
+      # enabled for an evaluation. We can't reuse these hashes because an application could call
+      # as_json and then modify the result.
+      case @kind
+      when :RULE_MATCH
+        { kind: @kind, ruleIndex: @rule_index, ruleId: @rule_id }
+      when :PREREQUISITE_FAILED
+        { kind: @kind, prerequisiteKey: @prerequisite_key }
+      when :ERROR
+        { kind: @kind, errorKind: @error_kind }
+      else
+        { kind: @kind }
+      end
+    end
+
+    # Same as {#as_json}, but converts the JSON structure into a string.
+    # @return [String]
+    def to_json(*a)
+      as_json.to_json(a)
+    end
+
+    # Allows this object to be treated as a hash corresponding to its JSON representation. For
+    # instance, if `reason.kind` is {#RULE_MATCH}, then `reason[:kind]` will be `"RULE_MATCH"` and
+    # `reason[:ruleIndex]` will be equal to `reason.rule_index`.
+    def [](key)
+      case key
+      when :kind
+        @kind.to_s
+      when :ruleIndex
+        @rule_index
+      when :ruleId
+        @rule_id
+      when :prerequisiteKey
+        @prerequisite_key
+      when :errorKind
+        @error_kind.nil? ? nil : @error_kind.to_s
+      else
+        nil
+      end
+    end
+
+    private
+
+    def initialize(kind, rule_index, rule_id, prerequisite_key, error_kind)
+      @kind = kind.to_sym
+      @rule_index = rule_index
+      @rule_id = rule_id
+      @rule_id.freeze if !rule_id.nil?
+      @prerequisite_key = prerequisite_key
+      @prerequisite_key.freeze if !prerequisite_key.nil?
+      @error_kind = error_kind
+    end
+
+    private_class_method :new
+
+    def self.make_error(error_kind)
+      new(:ERROR, nil, nil, nil, error_kind)
+    end
+
+    @@fallthrough = new(:FALLTHROUGH, nil, nil, nil, nil)
+    @@off = new(:OFF, nil, nil, nil, nil)
+    @@target_match = new(:TARGET_MATCH, nil, nil, nil, nil)
+    @@error_instances = {
+      ERROR_CLIENT_NOT_READY => make_error(ERROR_CLIENT_NOT_READY),
+      ERROR_FLAG_NOT_FOUND => make_error(ERROR_FLAG_NOT_FOUND),
+      ERROR_MALFORMED_FLAG => make_error(ERROR_MALFORMED_FLAG),
+      ERROR_USER_NOT_SPECIFIED => make_error(ERROR_USER_NOT_SPECIFIED),
+      ERROR_EXCEPTION => make_error(ERROR_EXCEPTION)
+    }
+  end
+end

data/lib/ldclient-rb/events.rb

@@ -238,10 +238,7 @@ module LaunchDarkly
         diagnostic_event_workers.shutdown
         diagnostic_event_workers.wait_for_termination
       end
-      begin
-        @client.finish
-      rescue
-      end
+      @event_sender.stop if @event_sender.respond_to?(:stop)
     end
 
     def synchronize_for_testing(flush_workers, diagnostic_event_workers)

data/lib/ldclient-rb/file_data_source.rb

@@ -51,7 +51,7 @@ module LaunchDarkly
   # output as the starting point for your file. In Linux you would do this:
   #
   # ```
-  #     curl -H "Authorization: YOUR_SDK_KEY" https://app.launchdarkly.com/sdk/latest-all
+  #     curl -H "Authorization: YOUR_SDK_KEY" https://sdk.launchdarkly.com/sdk/latest-all
   # ```
   #
   # The output will look something like this (but with many more properties):

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

@@ -0,0 +1,225 @@
+require "ldclient-rb/evaluation_detail"
+require "ldclient-rb/impl/evaluator_bucketing"
+require "ldclient-rb/impl/evaluator_operators"
+
+module LaunchDarkly
+  module Impl
+    # Encapsulates the feature flag evaluation logic. The Evaluator has no knowledge of the rest of the SDK environment;
+    # if it needs to retrieve flags or segments that are referenced by a flag, it does so through a simple function that
+    # is provided in the constructor. It also produces feature requests as appropriate for any referenced prerequisite
+    # flags, but does not send them.
+    class Evaluator
+      # A single Evaluator is instantiated for each client instance.
+      #
+      # @param get_flag [Function] called if the Evaluator needs to query a different flag from the one that it is
+      #   currently evaluating (i.e. a prerequisite flag); takes a single parameter, the flag key, and returns the
+      #   flag data - or nil if the flag is unknown or deleted
+      # @param get_segment [Function] similar to `get_flag`, but is used to query a user segment.
+      # @param logger [Logger] the client's logger
+      def initialize(get_flag, get_segment, logger)
+        @get_flag = get_flag
+        @get_segment = get_segment
+        @logger = logger
+      end
+
+      # Used internally to hold an evaluation result and the events that were generated from prerequisites. The
+      # `detail` property is an EvaluationDetail. The `events` property can be either an array of feature request
+      # events or nil.
+      EvalResult = Struct.new(:detail, :events)
+
+      # Helper function used internally to construct an EvaluationDetail for an error result.
+      def self.error_result(errorKind, value = nil)
+        EvaluationDetail.new(value, nil, EvaluationReason.error(errorKind))
+      end
+
+      # The client's entry point for evaluating a flag. The returned `EvalResult` contains the evaluation result and
+      # any events that were generated for prerequisite flags; its `value` will be `nil` if the flag returns the
+      # default value. Error conditions produce a result with a nil value and an error reason, not an exception.
+      #
+      # @param flag [Object] the flag
+      # @param user [Object] the user properties
+      # @param event_factory [EventFactory] called to construct a feature request event when a prerequisite flag is
+      #   evaluated; the caller is responsible for constructing the feature event for the top-level evaluation
+      # @return [EvalResult] the evaluation result 
+      def evaluate(flag, user, event_factory)
+        if user.nil? || user[:key].nil?
+          return EvalResult.new(Evaluator.error_result(EvaluationReason::ERROR_USER_NOT_SPECIFIED), [])
+        end
+
+        # If the flag doesn't have any prerequisites (which most flags don't) then it cannot generate any feature
+        # request events for prerequisites and we can skip allocating an array.
+        if flag[:prerequisites] && !flag[:prerequisites].empty?
+          events = []
+        else
+          events = nil
+        end
+
+        detail = eval_internal(flag, user, events, event_factory)
+        return EvalResult.new(detail, events.nil? || events.empty? ? nil : events)
+      end
+
+      private
+      
+      def eval_internal(flag, user, events, event_factory)
+        if !flag[:on]
+          return get_off_value(flag, EvaluationReason::off)
+        end
+
+        prereq_failure_reason = check_prerequisites(flag, user, events, event_factory)
+        if !prereq_failure_reason.nil?
+          return get_off_value(flag, prereq_failure_reason)
+        end
+
+        # Check user target matches
+        (flag[:targets] || []).each do |target|
+          (target[:values] || []).each do |value|
+            if value == user[:key]
+              return get_variation(flag, target[:variation], EvaluationReason::target_match)
+            end
+          end
+        end
+      
+        # Check custom rules
+        rules = flag[:rules] || []
+        rules.each_index do |i|
+          rule = rules[i]
+          if rule_match_user(rule, user)
+            reason = rule[:_reason]  # try to use cached reason for this rule
+            reason = EvaluationReason::rule_match(i, rule[:id]) if reason.nil?
+            return get_value_for_variation_or_rollout(flag, rule, user, reason)
+          end
+        end
+
+        # Check the fallthrough rule
+        if !flag[:fallthrough].nil?
+          return get_value_for_variation_or_rollout(flag, flag[:fallthrough], user, EvaluationReason::fallthrough)
+        end
+
+        return EvaluationDetail.new(nil, nil, EvaluationReason::fallthrough)
+      end
+
+      def check_prerequisites(flag, user, events, event_factory)
+        (flag[:prerequisites] || []).each do |prerequisite|
+          prereq_ok = true
+          prereq_key = prerequisite[:key]
+          prereq_flag = @get_flag.call(prereq_key)
+
+          if prereq_flag.nil?
+            @logger.error { "[LDClient] Could not retrieve prerequisite flag \"#{prereq_key}\" when evaluating \"#{flag[:key]}\"" }
+            prereq_ok = false
+          else
+            begin
+              prereq_res = eval_internal(prereq_flag, user, events, event_factory)
+              # Note that if the prerequisite flag is off, we don't consider it a match no matter what its
+              # off variation was. But we still need to evaluate it in order to generate an event.
+              if !prereq_flag[:on] || prereq_res.variation_index != prerequisite[:variation]
+                prereq_ok = false
+              end
+              event = event_factory.new_eval_event(prereq_flag, user, prereq_res, nil, flag)
+              events.push(event)
+            rescue => exn
+              Util.log_exception(@logger, "Error evaluating prerequisite flag \"#{prereq_key}\" for flag \"#{flag[:key]}\"", exn)
+              prereq_ok = false
+            end
+          end
+          if !prereq_ok
+            reason = prerequisite[:_reason]  # try to use cached reason
+            return reason.nil? ? EvaluationReason::prerequisite_failed(prereq_key) : reason
+          end
+        end
+        nil
+      end
+
+      def rule_match_user(rule, user)
+        return false if !rule[:clauses]
+
+        (rule[:clauses] || []).each do |clause|
+          return false if !clause_match_user(clause, user)
+        end
+
+        return true
+      end
+
+      def clause_match_user(clause, user)
+        # In the case of a segment match operator, we check if the user is in any of the segments,
+        # and possibly negate
+        if clause[:op].to_sym == :segmentMatch
+          result = (clause[:values] || []).any? { |v|
+            segment = @get_segment.call(v)
+            !segment.nil? && segment_match_user(segment, user)
+          }
+          clause[:negate] ? !result : result
+        else
+          clause_match_user_no_segments(clause, user)
+        end
+      end
+
+      def clause_match_user_no_segments(clause, user)
+        user_val = EvaluatorOperators.user_value(user, clause[:attribute])
+        return false if user_val.nil?
+
+        op = clause[:op].to_sym
+        clause_vals = clause[:values]
+        result = if user_val.is_a? Enumerable
+          user_val.any? { |uv| clause_vals.any? { |cv| EvaluatorOperators.apply(op, uv, cv) } }
+        else
+          clause_vals.any? { |cv| EvaluatorOperators.apply(op, user_val, cv) }
+        end
+        clause[:negate] ? !result : result
+      end
+
+      def segment_match_user(segment, user)
+        return false unless user[:key]
+
+        return true if segment[:included].include?(user[:key])
+        return false if segment[:excluded].include?(user[:key])
+
+        (segment[:rules] || []).each do |r|
+          return true if segment_rule_match_user(r, user, segment[:key], segment[:salt])
+        end
+
+        return false
+      end
+
+      def segment_rule_match_user(rule, user, segment_key, salt)
+        (rule[:clauses] || []).each do |c|
+          return false unless clause_match_user_no_segments(c, user)
+        end
+
+        # If the weight is absent, this rule matches
+        return true if !rule[:weight]
+        
+        # All of the clauses are met. See if the user buckets in
+        bucket = EvaluatorBucketing.bucket_user(user, segment_key, rule[:bucketBy].nil? ? "key" : rule[:bucketBy], salt)
+        weight = rule[:weight].to_f / 100000.0
+        return bucket < weight
+      end
+
+      private
+
+      def get_variation(flag, index, reason)
+        if index < 0 || index >= flag[:variations].length
+          @logger.error("[LDClient] Data inconsistency in feature flag \"#{flag[:key]}\": invalid variation index")
+          return Evaluator.error_result(EvaluationReason::ERROR_MALFORMED_FLAG)
+        end
+        EvaluationDetail.new(flag[:variations][index], index, reason)
+      end
+
+      def get_off_value(flag, reason)
+        if flag[:offVariation].nil?  # off variation unspecified - return default value
+          return EvaluationDetail.new(nil, nil, reason)
+        end
+        get_variation(flag, flag[:offVariation], reason)
+      end
+
+      def get_value_for_variation_or_rollout(flag, vr, user, reason)
+        index = EvaluatorBucketing.variation_index_for_user(flag, vr, user)
+        if index.nil?
+          @logger.error("[LDClient] Data inconsistency in feature flag \"#{flag[:key]}\": variation/rollout object with no variation or rollout")
+          return Evaluator.error_result(EvaluationReason::ERROR_MALFORMED_FLAG)
+        end
+        return get_variation(flag, index, reason)
+      end
+    end
+  end
+end