diff --git a/CHANGELOG.md b/CHANGELOG.md
index 3b81056b..848abd1f 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -2,6 +2,14 @@
 
 All notable changes to the LaunchDarkly Ruby SDK will be documented in this file. This project adheres to [Semantic Versioning](http://semver.org).
 
+## [5.2.0] - 2018-08-29
+### Added:
+- The new `LDClient` method `variation_detail` allows you to evaluate a feature flag (using the same parameters as you would for `variation`) and receive more information about how the value was calculated. This information is returned in an `EvaluationDetail` object, which contains both the result value and a "reason" object which will tell you, for instance, if the user was individually targeted for the flag or was matched by one of the flag's rules, or if the flag returned the default value due to an error.
+
+### Fixed:
+- Evaluating a prerequisite feature flag did not produce an analytics event if the prerequisite flag was off.
+
+ 
 ## [5.1.0] - 2018-08-27
 ### Added:
 - The new `LDClient` method `all_flags_state()` should be used instead of `all_flags()` if you are passing flag data to the front end for use with the JavaScript SDK. It preserves some flag metadata that the front end requires in order to send analytics events correctly. Versions 2.5.0 and above of the JavaScript SDK are able to use this metadata, but the output of `all_flags_state()` will still work with older versions.
diff --git a/lib/ldclient-rb/evaluation.rb b/lib/ldclient-rb/evaluation.rb
index b4dd796c..f73eb1ed 100644
--- a/lib/ldclient-rb/evaluation.rb
+++ b/lib/ldclient-rb/evaluation.rb
@@ -2,6 +2,37 @@
 require "semantic"
 
 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
+    def initialize(value, variation_index, reason)
+      @value = value
+      @variation_index = variation_index
+      @reason = reason
+    end
+
+    # @return [Object] The result of the flag evaluation. This will be either one of the flag's
+    #   variations or the default value that was passed to the `variation` method.
+    attr_reader :value
+
+    # @return [int|nil] The index of the returned value within the flag's list of variations, e.g.
+    #   0 for the first variation - or `nil` if the default value was returned.
+    attr_reader :variation_index
+
+    # @return [Hash] An object describing the main factor that influenced the flag evaluation value.
+    attr_reader :reason
+
+    # @return [boolean] True if the flag evaluated to the default value rather than to one of its
+    #   variations.
+    def default_value?
+      variation_index.nil?
+    end
+
+    def ==(other)
+      @value == other.value && @variation_index == other.variation_index && @reason == other.reason
+    end
+  end
+
   module Evaluation
     BUILTINS = [:key, :ip, :country, :email, :firstName, :lastName, :avatar, :name, :anonymous]
 
@@ -107,113 +138,103 @@ def self.comparator(converter)
         end
     }
 
-    class EvaluationError < StandardError
+    # Used internally to hold an evaluation result and the events that were generated from prerequisites.
+    EvalResult = Struct.new(:detail, :events)
+
+    def error_result(errorKind, value = nil)
+      EvaluationDetail.new(value, nil, { kind: 'ERROR', errorKind: errorKind })
     end
 
-    # Evaluates a feature flag, returning a hash containing the evaluation result and any events
-    # generated during prerequisite evaluation. Raises EvaluationError if the flag is not well-formed
-    # Will return nil, but not raise an exception, indicating that the rules (including fallthrough) did not match
-    # In that case, the caller should return the default value.
+    # Evaluates a feature flag and returns an EvalResult. The result.value will be nil if the flag returns
+    # the default value. Error conditions produce a result with an error reason, not an exception.
     def evaluate(flag, user, store, logger)
-      if flag.nil?
-        raise EvaluationError, "Flag does not exist"
-      end
-
       if user.nil? || user[:key].nil?
-        raise EvaluationError, "Invalid user"
+        return EvalResult.new(error_result('USER_NOT_SPECIFIED'), [])
       end
 
       events = []
+      detail = eval_internal(flag, user, store, events, logger)
+      return EvalResult.new(detail, events)
+    end
+
+    def eval_internal(flag, user, store, events, logger)
+      if !flag[:on]
+        return get_off_value(flag, { kind: 'OFF' }, logger)
+      end
 
-      if flag[:on]
-        res = eval_internal(flag, user, store, events, logger)
-        if !res.nil?
-          res[:events] = events
-          return res
+      prereq_failure_reason = check_prerequisites(flag, user, store, events, logger)
+      if !prereq_failure_reason.nil?
+        return get_off_value(flag, prereq_failure_reason, logger)
+      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], { kind: 'TARGET_MATCH' }, logger)
+          end
+        end
+      end
+    
+      # Check custom rules
+      rules = flag[:rules] || []
+      rules.each_index do |i|
+        rule = rules[i]
+        if rule_match_user(rule, user, store)
+          return get_value_for_variation_or_rollout(flag, rule, user,
+            { kind: 'RULE_MATCH', ruleIndex: i, ruleId: rule[:id] }, logger)
         end
       end
 
-      offVariation = flag[:offVariation]
-      if !offVariation.nil? && offVariation < flag[:variations].length
-        value = flag[:variations][offVariation]
-        return { variation: offVariation, value: value, events: events }
+      # Check the fallthrough rule
+      if !flag[:fallthrough].nil?
+        return get_value_for_variation_or_rollout(flag, flag[:fallthrough], user,
+          { kind: 'FALLTHROUGH' }, logger)
       end
 
-      { variation: nil, value: nil, events: events }
+      return EvaluationDetail.new(nil, nil, { kind: 'FALLTHROUGH' })
     end
 
-    def eval_internal(flag, user, store, events, logger)
-      failed_prereq = false
-      # Evaluate prerequisites, if any
+    def check_prerequisites(flag, user, store, events, logger)
       (flag[:prerequisites] || []).each do |prerequisite|
-        prereq_flag = store.get(FEATURES, prerequisite[:key])
+        prereq_ok = true
+        prereq_key = prerequisite[:key]
+        prereq_flag = store.get(FEATURES, prereq_key)
 
-        if prereq_flag.nil? || !prereq_flag[:on]
-          failed_prereq = true
+        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, store, events, logger)
+            # 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 = {
               kind: "feature",
-              key: prereq_flag[:key],
-              variation: prereq_res.nil? ? nil : prereq_res[:variation],
-              value: prereq_res.nil? ? nil : prereq_res[:value],
+              key: prereq_key,
+              variation: prereq_res.variation_index,
+              value: prereq_res.value,
               version: prereq_flag[:version],
               prereqOf: flag[:key],
               trackEvents: prereq_flag[:trackEvents],
               debugEventsUntilDate: prereq_flag[:debugEventsUntilDate]
             }
             events.push(event)
-            if prereq_res.nil? || prereq_res[:variation] != prerequisite[:variation]
-              failed_prereq = true
-            end
           rescue => exn
-            logger.error { "[LDClient] Error evaluating prerequisite: #{exn.inspect}" }
-            failed_prereq = true
+            Util.log_exception(logger, "Error evaluating prerequisite flag \"#{prereq_key}\" for flag \"{flag[:key]}\"", exn)
+            prereq_ok = false
           end
         end
-      end
-
-      if failed_prereq
-        return nil
-      end
-      # The prerequisites were satisfied.
-      # Now walk through the evaluation steps and get the correct
-      # variation index
-      eval_rules(flag, user, store)
-    end
-
-    def eval_rules(flag, user, store)
-      # Check user target matches
-      (flag[:targets] || []).each do |target|
-        (target[:values] || []).each do |value|
-          if value == user[:key]
-            return { variation: target[:variation], value: get_variation(flag, target[:variation]) }
-          end
+        if !prereq_ok
+          return { kind: 'PREREQUISITE_FAILED', prerequisiteKey: prereq_key }
         end
       end
-    
-      # Check custom rules
-      (flag[:rules] || []).each do |rule|
-        return variation_for_user(rule, user, flag) if rule_match_user(rule, user, store)
-      end
-
-      # Check the fallthrough rule
-      if !flag[:fallthrough].nil?
-        return variation_for_user(flag[:fallthrough], user, flag)
-      end
-
-      # Not even the fallthrough matched-- return the off variation or default
       nil
     end
 
-    def get_variation(flag, index)
-      if index >= flag[:variations].length
-        raise EvaluationError, "Invalid variation index"
-      end
-      flag[:variations][index]
-    end
-
     def rule_match_user(rule, user, store)
       return false if !rule[:clauses]
 
@@ -242,9 +263,8 @@ def clause_match_user_no_segments(clause, user)
       return false if val.nil?
 
       op = OPERATORS[clause[:op].to_sym]
-
       if op.nil?
-        raise EvaluationError, "Unsupported operator #{clause[:op]} in evaluation"
+        return false
       end
 
       if val.is_a? Enumerable
@@ -257,9 +277,9 @@ def clause_match_user_no_segments(clause, user)
       maybe_negate(clause, match_any(op, val, clause[:values]))
     end
 
-    def variation_for_user(rule, user, flag)
+    def variation_index_for_user(flag, rule, user)
       if !rule[:variation].nil? # fixed variation
-        return { variation: rule[:variation], value: get_variation(flag, rule[:variation]) }
+        return rule[:variation]
       elsif !rule[:rollout].nil? # percentage rollout
         rollout = rule[:rollout]
         bucket_by = rollout[:bucketBy].nil? ? "key" : rollout[:bucketBy]
@@ -268,12 +288,12 @@ def variation_for_user(rule, user, flag)
         rollout[:variations].each do |variate|
           sum += variate[:weight].to_f / 100000.0
           if bucket < sum
-            return { variation: variate[:variation], value: get_variation(flag, variate[:variation]) }
+            return variate[:variation]
           end
         end
         nil
       else # the rule isn't well-formed
-        raise EvaluationError, "Rule does not define a variation or rollout"
+        nil
       end
     end
 
@@ -350,5 +370,31 @@ def match_any(op, value, values)
       end
       return false
     end
+
+    private
+
+    def get_variation(flag, index, reason, logger)
+      if index < 0 || index >= flag[:variations].length
+        logger.error("[LDClient] Data inconsistency in feature flag \"#{flag[:key]}\": invalid variation index")
+        return error_result('MALFORMED_FLAG')
+      end
+      EvaluationDetail.new(flag[:variations][index], index, reason)
+    end
+
+    def get_off_value(flag, reason, logger)
+      if flag[:offVariation].nil?  # off variation unspecified - return default value
+        return EvaluationDetail.new(nil, nil, reason)
+      end
+      get_variation(flag, flag[:offVariation], reason, logger)
+    end
+
+    def get_value_for_variation_or_rollout(flag, vr, user, reason, logger)
+      index = 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 error_result('MALFORMED_FLAG')
+      end
+      return get_variation(flag, index, reason, logger)
+    end
   end
 end
diff --git a/lib/ldclient-rb/events.rb b/lib/ldclient-rb/events.rb
index 202fc235..e19d6b02 100644
--- a/lib/ldclient-rb/events.rb
+++ b/lib/ldclient-rb/events.rb
@@ -363,6 +363,7 @@ def make_output_event(event)
         else
           out[:userKey] = event[:user].nil? ? nil : event[:user][:key]
         end
+        out[:reason] = event[:reason] if !event[:reason].nil?
         out
       when "identify"
         {
diff --git a/lib/ldclient-rb/flags_state.rb b/lib/ldclient-rb/flags_state.rb
index 09f88975..05079920 100644
--- a/lib/ldclient-rb/flags_state.rb
+++ b/lib/ldclient-rb/flags_state.rb
@@ -15,12 +15,13 @@ def initialize(valid)
     end
 
     # Used internally to build the state map.
-    def add_flag(flag, value, variation)
+    def add_flag(flag, value, variation, reason = nil)
       key = flag[:key]
       @flag_values[key] = value
       meta = { version: flag[:version], trackEvents: flag[:trackEvents] }
       meta[:variation] = variation if !variation.nil?
       meta[:debugEventsUntilDate] = flag[:debugEventsUntilDate] if flag[:debugEventsUntilDate]
+      meta[:reason] = reason if !reason.nil?
       @flag_metadata[key] = meta
     end
 
diff --git a/lib/ldclient-rb/ldclient.rb b/lib/ldclient-rb/ldclient.rb
index e9873679..7e86662b 100644
--- a/lib/ldclient-rb/ldclient.rb
+++ b/lib/ldclient-rb/ldclient.rb
@@ -115,57 +115,54 @@ def initialized?
     # @param key [String] the unique feature key for the feature flag, as shown
     #   on the LaunchDarkly dashboard
     # @param user [Hash] a hash containing parameters for the end user requesting the flag
-    # @param default=false the default value of the flag
+    # @param default the default value of the flag
     #
     # @return the variation to show the user, or the
     #   default value if there's an an error
     def variation(key, user, default)
-      return default if @config.offline?
-
-      if !initialized?
-        if @store.initialized?
-          @config.logger.warn { "[LDClient] Client has not finished initializing; using last known values from feature store" }
-        else
-          @config.logger.error { "[LDClient] Client has not finished initializing; feature store unavailable, returning default value" }
-          @event_processor.add_event(kind: "feature", key: key, value: default, default: default, user: user)
-          return default
-        end
-      end
-
-      sanitize_user(user) if !user.nil?
-      feature = @store.get(FEATURES, key)
-
-      if feature.nil?
-        @config.logger.info { "[LDClient] Unknown feature flag #{key}. Returning default value" }
-        @event_processor.add_event(kind: "feature", key: key, value: default, default: default, user: user)
-        return default
-      end
-
-      unless user
-        @config.logger.error { "[LDClient] Must specify user" }
-        @event_processor.add_event(make_feature_event(feature, user, nil, default, default))
-        return default
-      end
+      evaluate_internal(key, user, default, false).value
+    end
 
-      begin
-        res = evaluate(feature, user, @store, @config.logger)
-        if !res[:events].nil?
-          res[:events].each do |event|
-            @event_processor.add_event(event)
-          end
-        end
-        value = res[:value]
-        if value.nil?
-          @config.logger.debug { "[LDClient] Result value is null in toggle" }
-          value = default
-        end
-        @event_processor.add_event(make_feature_event(feature, user, res[:variation], value, default))
-        return value
-      rescue => exn
-        Util.log_exception(@config.logger, "Error evaluating feature flag", exn)
-        @event_processor.add_event(make_feature_event(feature, user, nil, default, default))
-        return default
-      end
+    #
+    # Determines the variation of a feature flag for a user, like `variation`, but also
+    # provides additional information about how this value was calculated.
+    #
+    # The return value of `variation_detail` is an `EvaluationDetail` object, which has
+    # three properties:
+    #
+    # `value`: the value that was calculated for this user (same as the return value
+    # of `variation`)
+    #
+    # `variation_index`: the positional index of this value in the flag, e.g. 0 for the
+    # first variation - or `nil` if the default value was returned
+    #
+    # `reason`: a hash describing the main reason why this value was selected. Its `:kind`
+    # property will be one of the following:
+    #
+    # * `'OFF'`: the flag was off and therefore returned its configured off value
+    # * `'FALLTHROUGH'`: the flag was on but the user did not match any targets or rules
+    # * `'TARGET_MATCH'`: the user key was specifically targeted for this flag
+    # * `'RULE_MATCH'`: the user matched one of the flag's rules; the `:ruleIndex` and
+    # `:ruleId` properties indicate the positional index and unique identifier of the rule
+    # * `'PREREQUISITE_FAILED`': the flag was considered off because it had at least one
+    # prerequisite flag that either was off or did not return the desired variation; the
+    # `:prerequisiteKey` property indicates the key of the prerequisite that failed
+    # * `'ERROR'`: the flag could not be evaluated, e.g. because it does not exist or due
+    # to an unexpected error, and therefore returned the default value; the `:errorKind`
+    # property describes the nature of the error, such as `'FLAG_NOT_FOUND'`
+    #
+    # The `reason` will also be included in analytics events, if you are capturing
+    # detailed event data for this flag.
+    #
+    # @param key [String] the unique feature key for the feature flag, as shown
+    #   on the LaunchDarkly dashboard
+    # @param user [Hash] a hash containing parameters for the end user requesting the flag
+    # @param default the default value of the flag
+    #
+    # @return an `EvaluationDetail` object describing the result
+    #
+    def variation_detail(key, user, default)
+      evaluate_internal(key, user, default, true)
     end
 
     #
@@ -213,6 +210,8 @@ def all_flags(user)
     # @param options={} [Hash] Optional parameters to control how the state is generated
     # @option options [Boolean] :client_side_only (false) True if only flags marked for use with the
     #   client-side SDK should be included in the state. By default, all flags are included.
+    # @option options [Boolean] :with_reasons (false) True if evaluation reasons should be included
+    #   in the state (see `variation_detail`). By default, they are not included.
     # @return [FeatureFlagsState] a FeatureFlagsState object which can be serialized to JSON
     #
     def all_flags_state(user, options={})
@@ -234,16 +233,17 @@ def all_flags_state(user, options={})
 
       state = FeatureFlagsState.new(true)
       client_only = options[:client_side_only] || false
+      with_reasons = options[:with_reasons] || false
       features.each do |k, f|
         if client_only && !f[:clientSide]
           next
         end
         begin
           result = evaluate(f, user, @store, @config.logger)
-          state.add_flag(f, result[:value], result[:variation])
+          state.add_flag(f, result.detail.value, result.detail.variation_index, with_reasons ? result.detail.reason : nil)
         rescue => exn
           Util.log_exception(@config.logger, "Error evaluating flag \"#{k}\" in all_flags_state", exn)
-          state.add_flag(f, nil, nil)
+          state.add_flag(f, nil, nil, with_reasons ? { kind: 'ERROR', errorKind: 'EXCEPTION' } : nil)
         end
       end
 
@@ -261,27 +261,83 @@ def close
       @store.stop
     end
 
+    private
+
+    # @return [EvaluationDetail]
+    def evaluate_internal(key, user, default, include_reasons_in_events)
+      if @config.offline?
+        return error_result('CLIENT_NOT_READY', default)
+      end
+
+      if !initialized?
+        if @store.initialized?
+          @config.logger.warn { "[LDClient] Client has not finished initializing; using last known values from feature store" }
+        else
+          @config.logger.error { "[LDClient] Client has not finished initializing; feature store unavailable, returning default value" }
+          @event_processor.add_event(kind: "feature", key: key, value: default, default: default, user: user)
+          return error_result('CLIENT_NOT_READY', default)
+        end
+      end
+
+      sanitize_user(user) if !user.nil?
+      feature = @store.get(FEATURES, key)
+
+      if feature.nil?
+        @config.logger.info { "[LDClient] Unknown feature flag \"#{key}\". Returning default value" }
+        detail = error_result('FLAG_NOT_FOUND', default)
+        @event_processor.add_event(kind: "feature", key: key, value: default, default: default, user: user,
+          reason: include_reasons_in_events ? detail.reason : nil)
+        return detail
+      end
+
+      unless user
+        @config.logger.error { "[LDClient] Must specify user" }
+        detail = error_result('USER_NOT_SPECIFIED', default)
+        @event_processor.add_event(make_feature_event(feature, user, detail, default, include_reasons_in_events))
+        return detail
+      end
+
+      begin
+        res = evaluate(feature, user, @store, @config.logger)
+        if !res.events.nil?
+          res.events.each do |event|
+            @event_processor.add_event(event)
+          end
+        end
+        detail = res.detail
+        if detail.default_value?
+          detail = EvaluationDetail.new(default, nil, detail.reason)
+        end
+        @event_processor.add_event(make_feature_event(feature, user, detail, default, include_reasons_in_events))
+        return detail
+      rescue => exn
+        Util.log_exception(@config.logger, "Error evaluating feature flag \"#{key}\"", exn)
+        detail = error_result('EXCEPTION', default)
+        @event_processor.add_event(make_feature_event(feature, user, detail, default, include_reasons_in_events))
+        return detail
+      end
+    end
+
     def sanitize_user(user)
       if user[:key]
         user[:key] = user[:key].to_s
       end
     end
 
-    def make_feature_event(flag, user, variation, value, default)
+    def make_feature_event(flag, user, detail, default, with_reasons)
       {
         kind: "feature",
         key: flag[:key],
         user: user,
-        variation: variation,
-        value: value,
+        variation: detail.variation_index,
+        value: detail.value,
         default: default,
         version: flag[:version],
         trackEvents: flag[:trackEvents],
-        debugEventsUntilDate: flag[:debugEventsUntilDate]
+        debugEventsUntilDate: flag[:debugEventsUntilDate],
+        reason: with_reasons ? detail.reason : nil
       }
     end
-
-    private :evaluate, :sanitize_user, :make_feature_event
   end
 
   #
diff --git a/lib/ldclient-rb/version.rb b/lib/ldclient-rb/version.rb
index 1d54cc52..35f02783 100644
--- a/lib/ldclient-rb/version.rb
+++ b/lib/ldclient-rb/version.rb
@@ -1,3 +1,3 @@
 module LaunchDarkly
-  VERSION = "5.1.0"
+  VERSION = "5.2.0"
 end
diff --git a/spec/evaluation_spec.rb b/spec/evaluation_spec.rb
index a8d980ae..3af960c6 100644
--- a/spec/evaluation_spec.rb
+++ b/spec/evaluation_spec.rb
@@ -2,6 +2,9 @@
 
 describe LaunchDarkly::Evaluation do
   subject { LaunchDarkly::Evaluation }
+
+  include LaunchDarkly::Evaluation
+
   let(:features) { LaunchDarkly::InMemoryFeatureStore.new }
 
   let(:user) {
@@ -14,7 +17,13 @@
 
   let(:logger) { LaunchDarkly::Config.default_logger }
 
-  include LaunchDarkly::Evaluation
+  def boolean_flag_with_rules(rules)
+    { key: 'feature', on: true, rules: rules, fallthrough: { variation: 0 }, variations: [ false, true ] }
+  end
+
+  def boolean_flag_with_clauses(clauses)
+    boolean_flag_with_rules([{ id: 'ruleid', clauses: clauses, variation: 1 }])
+  end
 
   describe "evaluate" do
     it "returns off variation if flag is off" do
@@ -26,7 +35,10 @@
         variations: ['a', 'b', 'c']
       }
       user = { key: 'x' }
-      expect(evaluate(flag, user, features, logger)).to eq({variation: 1, value: 'b', events: []})
+      detail = LaunchDarkly::EvaluationDetail.new('b', 1, { kind: 'OFF' })
+      result = evaluate(flag, user, features, logger)
+      expect(result.detail).to eq(detail)
+      expect(result.events).to eq([])
     end
 
     it "returns nil if flag is off and off variation is unspecified" do
@@ -37,7 +49,42 @@
         variations: ['a', 'b', 'c']
       }
       user = { key: 'x' }
-      expect(evaluate(flag, user, features, logger)).to eq({variation: nil, value: nil, events: []})
+      detail = LaunchDarkly::EvaluationDetail.new(nil, nil, { kind: 'OFF' })
+      result = evaluate(flag, user, features, logger)
+      expect(result.detail).to eq(detail)
+      expect(result.events).to eq([])
+    end
+
+    it "returns an error if off variation is too high" do
+      flag = {
+        key: 'feature',
+        on: false,
+        offVariation: 999,
+        fallthrough: { variation: 0 },
+        variations: ['a', 'b', 'c']
+      }
+      user = { key: 'x' }
+      detail = LaunchDarkly::EvaluationDetail.new(nil, nil,
+        { kind: 'ERROR', errorKind: 'MALFORMED_FLAG' })
+      result = evaluate(flag, user, features, logger)
+      expect(result.detail).to eq(detail)
+      expect(result.events).to eq([])
+    end
+
+    it "returns an error if off variation is negative" do
+      flag = {
+        key: 'feature',
+        on: false,
+        offVariation: -1,
+        fallthrough: { variation: 0 },
+        variations: ['a', 'b', 'c']
+      }
+      user = { key: 'x' }
+      detail = LaunchDarkly::EvaluationDetail.new(nil, nil,
+        { kind: 'ERROR', errorKind: 'MALFORMED_FLAG' })
+      result = evaluate(flag, user, features, logger)
+      expect(result.detail).to eq(detail)
+      expect(result.events).to eq([])
     end
 
     it "returns off variation if prerequisite is not found" do
@@ -50,7 +97,11 @@
         variations: ['a', 'b', 'c']
       }
       user = { key: 'x' }
-      expect(evaluate(flag, user, features, logger)).to eq({variation: 1, value: 'b', events: []})
+      detail = LaunchDarkly::EvaluationDetail.new('b', 1,
+        { kind: 'PREREQUISITE_FAILED', prerequisiteKey: 'badfeature' })
+      result = evaluate(flag, user, features, logger)
+      expect(result.detail).to eq(detail)
+      expect(result.events).to eq([])
     end
 
     it "returns off variation and event if prerequisite of a prerequisite is not found" do
@@ -73,11 +124,47 @@
       }
       features.upsert(LaunchDarkly::FEATURES, flag1)
       user = { key: 'x' }
+      detail = LaunchDarkly::EvaluationDetail.new('b', 1,
+        { kind: 'PREREQUISITE_FAILED', prerequisiteKey: 'feature1' })
       events_should_be = [{
         kind: 'feature', key: 'feature1', variation: nil, value: nil, version: 2, prereqOf: 'feature0',
         trackEvents: nil, debugEventsUntilDate: nil
       }]
-      expect(evaluate(flag, user, features, logger)).to eq({variation: 1, value: 'b', events: events_should_be})
+      result = evaluate(flag, user, features, logger)
+      expect(result.detail).to eq(detail)
+      expect(result.events).to eq(events_should_be)
+    end
+
+    it "returns off variation and event if prerequisite is off" do
+      flag = {
+        key: 'feature0',
+        on: true,
+        prerequisites: [{key: 'feature1', variation: 1}],
+        fallthrough: { variation: 0 },
+        offVariation: 1,
+        variations: ['a', 'b', 'c'],
+        version: 1
+      }
+      flag1 = {
+        key: 'feature1',
+        on: false,
+        # note that even though it returns the desired variation, it is still off and therefore not a match
+        offVariation: 1,
+        fallthrough: { variation: 0 },
+        variations: ['d', 'e'],
+        version: 2
+      }
+      features.upsert(LaunchDarkly::FEATURES, flag1)
+      user = { key: 'x' }
+      detail = LaunchDarkly::EvaluationDetail.new('b', 1,
+        { kind: 'PREREQUISITE_FAILED', prerequisiteKey: 'feature1' })
+      events_should_be = [{
+        kind: 'feature', key: 'feature1', variation: 1, value: 'e', version: 2, prereqOf: 'feature0',
+        trackEvents: nil, debugEventsUntilDate: nil
+      }]
+      result = evaluate(flag, user, features, logger)
+      expect(result.detail).to eq(detail)
+      expect(result.events).to eq(events_should_be)
     end
 
     it "returns off variation and event if prerequisite is not met" do
@@ -99,11 +186,15 @@
       }
       features.upsert(LaunchDarkly::FEATURES, flag1)
       user = { key: 'x' }
+      detail = LaunchDarkly::EvaluationDetail.new('b', 1,
+        { kind: 'PREREQUISITE_FAILED', prerequisiteKey: 'feature1' })
       events_should_be = [{
         kind: 'feature', key: 'feature1', variation: 0, value: 'd', version: 2, prereqOf: 'feature0',
         trackEvents: nil, debugEventsUntilDate: nil
       }]
-      expect(evaluate(flag, user, features, logger)).to eq({variation: 1, value: 'b', events: events_should_be})
+      result = evaluate(flag, user, features, logger)
+      expect(result.detail).to eq(detail)
+      expect(result.events).to eq(events_should_be)
     end
 
     it "returns fallthrough variation and event if prerequisite is met and there are no rules" do
@@ -125,76 +216,195 @@
       }
       features.upsert(LaunchDarkly::FEATURES, flag1)
       user = { key: 'x' }
+      detail = LaunchDarkly::EvaluationDetail.new('a', 0, { kind: 'FALLTHROUGH' })
       events_should_be = [{
         kind: 'feature', key: 'feature1', variation: 1, value: 'e', version: 2, prereqOf: 'feature0',
         trackEvents: nil, debugEventsUntilDate: nil
       }]
-      expect(evaluate(flag, user, features, logger)).to eq({variation: 0, value: 'a', events: events_should_be})
+      result = evaluate(flag, user, features, logger)
+      expect(result.detail).to eq(detail)
+      expect(result.events).to eq(events_should_be)
     end
 
-    it "matches user from targets" do
+    it "returns an error if fallthrough variation is too high" do
       flag = {
-        key: 'feature0',
+        key: 'feature',
         on: true,
-        targets: [
-          { values: [ 'whoever', 'userkey' ], variation: 2 }
-        ],
-        fallthrough: { variation: 0 },
+        fallthrough: { variation: 999 },
         offVariation: 1,
         variations: ['a', 'b', 'c']
       }
       user = { key: 'userkey' }
-      expect(evaluate(flag, user, features, logger)).to eq({variation: 2, value: 'c', events: []})
+      detail = LaunchDarkly::EvaluationDetail.new(nil, nil, { kind: 'ERROR', errorKind: 'MALFORMED_FLAG' })
+      result = evaluate(flag, user, features, logger)
+      expect(result.detail).to eq(detail)
+      expect(result.events).to eq([])
     end
 
-    it "matches user from rules" do
+    it "returns an error if fallthrough variation is negative" do
       flag = {
-        key: 'feature0',
+        key: 'feature',
         on: true,
-        rules: [
-          {
-            clauses: [
-              {
-                attribute: 'key',
-                op: 'in',
-                values: [ 'userkey' ]
-              }
-            ],
-            variation: 2
-          }
+        fallthrough: { variation: -1 },
+        offVariation: 1,
+        variations: ['a', 'b', 'c']
+      }
+      user = { key: 'userkey' }
+      detail = LaunchDarkly::EvaluationDetail.new(nil, nil, { kind: 'ERROR', errorKind: 'MALFORMED_FLAG' })
+      result = evaluate(flag, user, features, logger)
+      expect(result.detail).to eq(detail)
+      expect(result.events).to eq([])
+    end
+
+    it "returns an error if fallthrough has no variation or rollout" do
+      flag = {
+        key: 'feature',
+        on: true,
+        fallthrough: { },
+        offVariation: 1,
+        variations: ['a', 'b', 'c']
+      }
+      user = { key: 'userkey' }
+      detail = LaunchDarkly::EvaluationDetail.new(nil, nil, { kind: 'ERROR', errorKind: 'MALFORMED_FLAG' })
+      result = evaluate(flag, user, features, logger)
+      expect(result.detail).to eq(detail)
+      expect(result.events).to eq([])
+    end
+
+    it "returns an error if fallthrough has a rollout with no variations" do
+      flag = {
+        key: 'feature',
+        on: true,
+        fallthrough: { rollout: { variations: [] } },
+        offVariation: 1,
+        variations: ['a', 'b', 'c']
+      }
+      user = { key: 'userkey' }
+      detail = LaunchDarkly::EvaluationDetail.new(nil, nil, { kind: 'ERROR', errorKind: 'MALFORMED_FLAG' })
+      result = evaluate(flag, user, features, logger)
+      expect(result.detail).to eq(detail)
+      expect(result.events).to eq([])
+    end
+
+    it "matches user from targets" do
+      flag = {
+        key: 'feature',
+        on: true,
+        targets: [
+          { values: [ 'whoever', 'userkey' ], variation: 2 }
         ],
         fallthrough: { variation: 0 },
         offVariation: 1,
         variations: ['a', 'b', 'c']
       }
       user = { key: 'userkey' }
-      expect(evaluate(flag, user, features, logger)).to eq({variation: 2, value: 'c', events: []})
+      detail = LaunchDarkly::EvaluationDetail.new('c', 2, { kind: 'TARGET_MATCH' })
+      result = evaluate(flag, user, features, logger)
+      expect(result.detail).to eq(detail)
+      expect(result.events).to eq([])
+    end
+
+    it "matches user from rules" do
+      rule = { id: 'ruleid', clauses: [{ attribute: 'key', op: 'in', values: ['userkey'] }], variation: 1 }
+      flag = boolean_flag_with_rules([rule])
+      user = { key: 'userkey' }
+      detail = LaunchDarkly::EvaluationDetail.new(true, 1,
+        { kind: 'RULE_MATCH', ruleIndex: 0, ruleId: 'ruleid' })
+      result = evaluate(flag, user, features, logger)
+      expect(result.detail).to eq(detail)
+      expect(result.events).to eq([])
+    end
+
+    it "returns an error if rule variation is too high" do
+      rule = { id: 'ruleid', clauses: [{ attribute: 'key', op: 'in', values: ['userkey'] }], variation: 999 }
+      flag = boolean_flag_with_rules([rule])
+      user = { key: 'userkey' }
+      detail = LaunchDarkly::EvaluationDetail.new(nil, nil,
+        { kind: 'ERROR', errorKind: 'MALFORMED_FLAG' })
+      result = evaluate(flag, user, features, logger)
+      expect(result.detail).to eq(detail)
+      expect(result.events).to eq([])
+    end
+
+    it "returns an error if rule variation is negative" do
+      rule = { id: 'ruleid', clauses: [{ attribute: 'key', op: 'in', values: ['userkey'] }], variation: -1 }
+      flag = boolean_flag_with_rules([rule])
+      user = { key: 'userkey' }
+      detail = LaunchDarkly::EvaluationDetail.new(nil, nil,
+        { kind: 'ERROR', errorKind: 'MALFORMED_FLAG' })
+      result = evaluate(flag, user, features, logger)
+      expect(result.detail).to eq(detail)
+      expect(result.events).to eq([])
+    end
+
+    it "returns an error if rule has neither variation nor rollout" do
+      rule = { id: 'ruleid', clauses: [{ attribute: 'key', op: 'in', values: ['userkey'] }] }
+      flag = boolean_flag_with_rules([rule])
+      user = { key: 'userkey' }
+      detail = LaunchDarkly::EvaluationDetail.new(nil, nil,
+        { kind: 'ERROR', errorKind: 'MALFORMED_FLAG' })
+      result = evaluate(flag, user, features, logger)
+      expect(result.detail).to eq(detail)
+      expect(result.events).to eq([])
+    end
+
+    it "returns an error if rule has a rollout with no variations" do
+      rule = { id: 'ruleid', clauses: [{ attribute: 'key', op: 'in', values: ['userkey'] }],
+        rollout: { variations: [] } }
+      flag = boolean_flag_with_rules([rule])
+      user = { key: 'userkey' }
+      detail = LaunchDarkly::EvaluationDetail.new(nil, nil,
+        { kind: 'ERROR', errorKind: 'MALFORMED_FLAG' })
+      result = evaluate(flag, user, features, logger)
+      expect(result.detail).to eq(detail)
+      expect(result.events).to eq([])
     end
   end
 
-  describe "clause_match_user" do
+  describe "clause" do
     it "can match built-in attribute" do
       user = { key: 'x', name: 'Bob' }
       clause = { attribute: 'name', op: 'in', values: ['Bob'] }
-      expect(clause_match_user(clause, user, features)).to be true
+      flag = boolean_flag_with_clauses([clause])
+      expect(evaluate(flag, user, features, logger).detail.value).to be true
     end
 
     it "can match custom attribute" do
       user = { key: 'x', name: 'Bob', custom: { legs: 4 } }
       clause = { attribute: 'legs', op: 'in', values: [4] }
-      expect(clause_match_user(clause, user, features)).to be true
+      flag = boolean_flag_with_clauses([clause])
+      expect(evaluate(flag, user, features, logger).detail.value).to be true
     end
 
     it "returns false for missing attribute" do
       user = { key: 'x', name: 'Bob' }
       clause = { attribute: 'legs', op: 'in', values: [4] }
-      expect(clause_match_user(clause, user, features)).to be false
+      flag = boolean_flag_with_clauses([clause])
+      expect(evaluate(flag, user, features, logger).detail.value).to be false
+    end
+
+    it "returns false for unknown operator" do
+      user = { key: 'x', name: 'Bob' }
+      clause = { attribute: 'name', op: 'unknown', values: [4] }
+      flag = boolean_flag_with_clauses([clause])
+      expect(evaluate(flag, user, features, logger).detail.value).to be false
+    end
+
+    it "does not stop evaluating rules after clause with unknown operator" do
+      user = { key: 'x', name: 'Bob' }
+      clause0 = { attribute: 'name', op: 'unknown', values: [4] }
+      rule0 = { clauses: [ clause0 ], variation: 1 }
+      clause1 = { attribute: 'name', op: 'in', values: ['Bob'] }
+      rule1 = { clauses: [ clause1 ], variation: 1 }
+      flag = boolean_flag_with_rules([rule0, rule1])
+      expect(evaluate(flag, user, features, logger).detail.value).to be true
     end
 
     it "can be negated" do
       user = { key: 'x', name: 'Bob' }
       clause = { attribute: 'name', op: 'in', values: ['Bob'], negate: true }
-      expect(clause_match_user(clause, user, features)).to be false
+      flag = boolean_flag_with_clauses([clause])
+      expect(evaluate(flag, user, features, logger).detail.value).to be false
     end
 
     it "retrieves segment from segment store for segmentMatch operator" do
@@ -208,23 +418,24 @@
 
       user = { key: 'userkey' }
       clause = { attribute: '', op: 'segmentMatch', values: ['segkey'] }
-
-      expect(clause_match_user(clause, user, features)).to be true
+      flag = boolean_flag_with_clauses([clause])
+      expect(evaluate(flag, user, features, logger).detail.value).to be true
     end
 
     it "falls through with no errors if referenced segment is not found" do
       user = { key: 'userkey' }
       clause = { attribute: '', op: 'segmentMatch', values: ['segkey'] }
-
-      expect(clause_match_user(clause, user, features)).to be false
+      flag = boolean_flag_with_clauses([clause])
+      expect(evaluate(flag, user, features, logger).detail.value).to be false
     end
 
     it "can be negated" do
       user = { key: 'x', name: 'Bob' }
       clause = { attribute: 'name', op: 'in', values: ['Bob'] }
+      flag = boolean_flag_with_clauses([clause])
       expect {
          clause[:negate] = true
-      }.to change {clause_match_user(clause, user, features)}.from(true).to(false)
+      }.to change {evaluate(flag, user, features, logger).detail.value}.from(true).to(false)
     end
   end
 
@@ -326,7 +537,8 @@
       it "should return #{shouldBe} for #{value1} #{op} #{value2}" do
         user = { key: 'x', custom: { foo: value1 } }
         clause = { attribute: 'foo', op: op, values: [value2] }
-        expect(clause_match_user(clause, user, features)).to be shouldBe
+        flag = boolean_flag_with_clauses([clause])
+        expect(evaluate(flag, user, features, logger).detail.value).to be shouldBe
       end
     end
   end
@@ -385,17 +597,6 @@
     end
   end
   
-  def make_flag(key)
-    {
-      key: key,
-      rules: [],
-      variations: [ false, true ],
-      on: true,
-      fallthrough: { variation: 0 },
-      version: 1
-    }
-  end
-
   def make_segment(key)
     {
       key: key,
@@ -424,35 +625,30 @@ def make_user_matching_clause(user, attr)
   end
 
   describe 'segment matching' do
-    it 'explicitly includes user' do
-      segment = make_segment('segkey')
-      segment[:included] = [ user[:key] ]
+    def test_segment_match(segment)
       features.upsert(LaunchDarkly::SEGMENTS, segment)
       clause = make_segment_match_clause(segment)
+      flag = boolean_flag_with_clauses([clause])
+      evaluate(flag, user, features, logger).detail.value
+    end
 
-      result = clause_match_user(clause, user, features)
-      expect(result).to be true
+    it 'explicitly includes user' do
+      segment = make_segment('segkey')
+      segment[:included] = [ user[:key] ]
+      expect(test_segment_match(segment)).to be true
     end
 
     it 'explicitly excludes user' do
       segment = make_segment('segkey')
       segment[:excluded] = [ user[:key] ]
-      features.upsert(LaunchDarkly::SEGMENTS, segment)
-      clause = make_segment_match_clause(segment)
-
-      result = clause_match_user(clause, user, features)
-      expect(result).to be false
+      expect(test_segment_match(segment)).to be false
     end
 
     it 'both includes and excludes user; include takes priority' do
       segment = make_segment('segkey')
       segment[:included] = [ user[:key] ]
       segment[:excluded] = [ user[:key] ]
-      features.upsert(LaunchDarkly::SEGMENTS, segment)
-      clause = make_segment_match_clause(segment)
-
-      result = clause_match_user(clause, user, features)
-      expect(result).to be true
+      expect(test_segment_match(segment)).to be true
     end
 
     it 'matches user by rule when weight is absent' do
@@ -462,11 +658,7 @@ def make_user_matching_clause(user, attr)
       }
       segment = make_segment('segkey')
       segment[:rules] = [ segRule ]
-      features.upsert(LaunchDarkly::SEGMENTS, segment)
-      clause = make_segment_match_clause(segment)
-
-      result = clause_match_user(clause, user, features)
-      expect(result).to be true
+      expect(test_segment_match(segment)).to be true
     end
 
     it 'matches user by rule when weight is nil' do
@@ -477,11 +669,7 @@ def make_user_matching_clause(user, attr)
       }
       segment = make_segment('segkey')
       segment[:rules] = [ segRule ]
-      features.upsert(LaunchDarkly::SEGMENTS, segment)
-      clause = make_segment_match_clause(segment)
-
-      result = clause_match_user(clause, user, features)
-      expect(result).to be true
+      expect(test_segment_match(segment)).to be true
     end
 
     it 'matches user with full rollout' do
@@ -492,11 +680,7 @@ def make_user_matching_clause(user, attr)
       }
       segment = make_segment('segkey')
       segment[:rules] = [ segRule ]
-      features.upsert(LaunchDarkly::SEGMENTS, segment)
-      clause = make_segment_match_clause(segment)
-
-      result = clause_match_user(clause, user, features)
-      expect(result).to be true
+      expect(test_segment_match(segment)).to be true
     end
 
     it "doesn't match user with zero rollout" do
@@ -507,11 +691,7 @@ def make_user_matching_clause(user, attr)
       }
       segment = make_segment('segkey')
       segment[:rules] = [ segRule ]
-      features.upsert(LaunchDarkly::SEGMENTS, segment)
-      clause = make_segment_match_clause(segment)
-
-      result = clause_match_user(clause, user, features)
-      expect(result).to be false
+      expect(test_segment_match(segment)).to be false
     end
 
     it "matches user with multiple clauses" do
@@ -522,11 +702,7 @@ def make_user_matching_clause(user, attr)
       }
       segment = make_segment('segkey')
       segment[:rules] = [ segRule ]
-      features.upsert(LaunchDarkly::SEGMENTS, segment)
-      clause = make_segment_match_clause(segment)
-
-      result = clause_match_user(clause, user, features)
-      expect(result).to be true
+      expect(test_segment_match(segment)).to be true
     end
 
     it "doesn't match user with multiple clauses if a clause doesn't match" do
@@ -538,11 +714,7 @@ def make_user_matching_clause(user, attr)
       }
       segment = make_segment('segkey')
       segment[:rules] = [ segRule ]
-      features.upsert(LaunchDarkly::SEGMENTS, segment)
-      clause = make_segment_match_clause(segment)
-
-      result = clause_match_user(clause, user, features)
-      expect(result).to be false
+      expect(test_segment_match(segment)).to be false
     end
   end
 end
diff --git a/spec/ldclient_spec.rb b/spec/ldclient_spec.rb
index ae76a678..d76f7834 100644
--- a/spec/ldclient_spec.rb
+++ b/spec/ldclient_spec.rb
@@ -34,11 +34,18 @@ def event_processor
   end
 
   describe '#variation' do
-    it "will return the default value if the client is offline" do
+    feature_with_value = { key: "key", on: false, offVariation: 0, variations: ["value"], version: 100,
+      trackEvents: true, debugEventsUntilDate: 1000 }
+
+    it "returns the default value if the client is offline" do
       result = offline_client.variation("doesntmatter", user, "default")
       expect(result).to eq "default"
     end
 
+    it "returns the default value for an unknown feature" do
+      expect(client.variation("badkey", user, "default")).to eq "default"
+    end
+
     it "queues a feature request event for an unknown feature" do
       expect(event_processor).to receive(:add_event).with(hash_including(
         kind: "feature", key: "badkey", user: user, value: "default", default: "default"
@@ -46,56 +53,130 @@ def event_processor
       client.variation("badkey", user, "default")
     end
 
+    it "returns the value for an existing feature" do
+      config.feature_store.init({ LaunchDarkly::FEATURES => {} })
+      config.feature_store.upsert(LaunchDarkly::FEATURES, feature_with_value)
+      expect(client.variation("key", user, "default")).to eq "value"
+    end
+
+    it "returns the default value if a feature evaluates to nil" do
+      empty_feature = { key: "key", on: false, offVariation: nil }
+      config.feature_store.init({ LaunchDarkly::FEATURES => {} })
+      config.feature_store.upsert(LaunchDarkly::FEATURES, empty_feature)
+      expect(client.variation("key", user, "default")).to eq "default"
+    end
+
     it "queues a feature request event for an existing feature" do
       config.feature_store.init({ LaunchDarkly::FEATURES => {} })
-      config.feature_store.upsert(LaunchDarkly::FEATURES, feature)
+      config.feature_store.upsert(LaunchDarkly::FEATURES, feature_with_value)
       expect(event_processor).to receive(:add_event).with(hash_including(
         kind: "feature",
-        key: feature[:key],
-        version: feature[:version],
+        key: "key",
+        version: 100,
         user: user,
         variation: 0,
-        value: true,
+        value: "value",
         default: "default",
         trackEvents: true,
-        debugEventsUntilDate: nil
+        debugEventsUntilDate: 1000
       ))
-      client.variation(feature[:key], user, "default")
+      client.variation("key", user, "default")
     end
 
     it "queues a feature event for an existing feature when user is nil" do
       config.feature_store.init({ LaunchDarkly::FEATURES => {} })
-      config.feature_store.upsert(LaunchDarkly::FEATURES, feature)
+      config.feature_store.upsert(LaunchDarkly::FEATURES, feature_with_value)
       expect(event_processor).to receive(:add_event).with(hash_including(
         kind: "feature",
-        key: feature[:key],
-        version: feature[:version],
+        key: "key",
+        version: 100,
         user: nil,
         variation: nil,
         value: "default",
         default: "default",
         trackEvents: true,
-        debugEventsUntilDate: nil
+        debugEventsUntilDate: 1000
       ))
-      client.variation(feature[:key], nil, "default")
+      client.variation("key", nil, "default")
     end
 
     it "queues a feature event for an existing feature when user key is nil" do
       config.feature_store.init({ LaunchDarkly::FEATURES => {} })
-      config.feature_store.upsert(LaunchDarkly::FEATURES, feature)
+      config.feature_store.upsert(LaunchDarkly::FEATURES, feature_with_value)
       bad_user = { name: "Bob" }
       expect(event_processor).to receive(:add_event).with(hash_including(
         kind: "feature",
-        key: feature[:key],
-        version: feature[:version],
+        key: "key",
+        version: 100,
         user: bad_user,
         variation: nil,
         value: "default",
         default: "default",
         trackEvents: true,
-        debugEventsUntilDate: nil
+        debugEventsUntilDate: 1000
+      ))
+      client.variation("key", bad_user, "default")
+    end
+  end
+
+  describe '#variation_detail' do
+    feature_with_value = { key: "key", on: false, offVariation: 0, variations: ["value"], version: 100,
+      trackEvents: true, debugEventsUntilDate: 1000 }
+
+    it "returns the default value if the client is offline" do
+      result = offline_client.variation_detail("doesntmatter", user, "default")
+      expected = LaunchDarkly::EvaluationDetail.new("default", nil, { kind: 'ERROR', errorKind: 'CLIENT_NOT_READY' })
+      expect(result).to eq expected
+    end
+
+    it "returns the default value for an unknown feature" do
+      result = client.variation_detail("badkey", user, "default")
+      expected = LaunchDarkly::EvaluationDetail.new("default", nil, { kind: 'ERROR', errorKind: 'FLAG_NOT_FOUND'})
+      expect(result).to eq expected
+    end
+
+    it "queues a feature request event for an unknown feature" do
+      expect(event_processor).to receive(:add_event).with(hash_including(
+        kind: "feature", key: "badkey", user: user, value: "default", default: "default",
+        reason: { kind: 'ERROR', errorKind: 'FLAG_NOT_FOUND' }
+      ))
+      client.variation_detail("badkey", user, "default")
+    end
+
+    it "returns a value for an existing feature" do
+      config.feature_store.init({ LaunchDarkly::FEATURES => {} })
+      config.feature_store.upsert(LaunchDarkly::FEATURES, feature_with_value)
+      result = client.variation_detail("key", user, "default")
+      expected = LaunchDarkly::EvaluationDetail.new("value", 0, { kind: 'OFF' })
+      expect(result).to eq expected
+    end
+
+    it "returns the default value if a feature evaluates to nil" do
+      empty_feature = { key: "key", on: false, offVariation: nil }
+      config.feature_store.init({ LaunchDarkly::FEATURES => {} })
+      config.feature_store.upsert(LaunchDarkly::FEATURES, empty_feature)
+      result = client.variation_detail("key", user, "default")
+      expected = LaunchDarkly::EvaluationDetail.new("default", nil, { kind: 'OFF' })
+      expect(result).to eq expected
+      expect(result.default_value?).to be true
+    end
+
+    it "queues a feature request event for an existing feature" do
+      config.feature_store.init({ LaunchDarkly::FEATURES => {} })
+      config.feature_store.upsert(LaunchDarkly::FEATURES, feature_with_value)
+      expect(event_processor).to receive(:add_event).with(hash_including(
+        kind: "feature",
+        key: "key",
+        version: 100,
+        user: user,
+        variation: 0,
+        value: "value",
+        default: "default",
+        trackEvents: true,
+        debugEventsUntilDate: 1000,
+        reason: { kind: "OFF" }
       ))
-      client.variation(feature[:key], bad_user, "default")
+      client.variation_detail("key", user, "default")
     end
   end