launchdarkly-server-sdk 6.1.1 → 6.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 631066b2968b323ed2e12aed1565c76cf1f8bb6284e8372121771577b49bda18
-  data.tar.gz: 3e6b7c3b9769c917996e844c598796912f19c20e796692b877a885886d8fa070
+  metadata.gz: 1ee671939e04661c649d31502496cc33cd8844002c9af06864db9f322a81ec56
+  data.tar.gz: f5f77f10a6c487e1846f8d86201e9456b04bfb03950c751a328a7d3b9c3b8597
 SHA512:
-  metadata.gz: 5a885a5714a9cc157e295dd1a88a353a546847a702a771b4edf49f33c081eb19c4141ee7a0b4a8004620c1a4c20ef0111af0c0900ee3a28845f29e2385ebd13c
-  data.tar.gz: 6e604eac4e997431d09257bf97ec115f3a130293e4bc83fa08254baaa921eb28a2230e5bc2bd080c855293e773331e5eed006741db6cd9943132a1f2a1dc243d
+  metadata.gz: 6dc025a98ed3ab25bfe14baa878ff36beb34875caafee9c1979c724d58af9d08ca2596615cb31819dbb150fdeffd17b597f76e19cf2f09962dc1095ffe686ea7
+  data.tar.gz: 5d22b72feb1b46e7537f00b3959c72368d94c6606db640df1a7a9b17e1b01b952f1d34ea260e8d20b661fdee558975a9e034087e0d785aacd297d20ab15e9944

data/.circleci/config.yml

@@ -20,7 +20,7 @@ jobs:
       LD_RELEASE_DOCS_TITLE: ""
       LD_RELEASE_PROJECT: "ruby-server-sdk"
       LD_RELEASE_PROJECT_TEMPLATE: "ruby"
-      LD_RELEASE_VERSION: "6.1.1"
+      LD_RELEASE_VERSION: "6.2.0"
       LD_SKIP_DATABASE_TESTS: "1"
     steps:
       - checkout

data/CHANGELOG.md

@@ -2,6 +2,10 @@
 
 All notable changes to the LaunchDarkly Ruby SDK will be documented in this file. This project adheres to [Semantic Versioning](http://semver.org).
 
+## [6.1.1] - 2021-05-27
+### Fixed:
+- Calling `variation` with a nil user parameter is invalid, causing the SDK to log an error and return a fallback value, but the SDK was still sending an analytics event for this. An event without a user is meaningless and can't be processed by LaunchDarkly. This is now fixed so the SDK will not send one.
+
 ## [6.1.0] - 2021-02-04
 ### Added:
 - Added the `alias` method. This can be used to associate two user objects for analytics purposes by generating an alias event.

data/lib/ldclient-rb/evaluation_detail.rb

@@ -120,6 +120,9 @@ module LaunchDarkly
     # or deleted. If {#kind} is not {#RULE_MATCH}, this will be `nil`.
     attr_reader :rule_id
 
+    # A boolean or nil value representing if the rule or fallthrough has an experiment rollout.
+    attr_reader :in_experiment
+
     # 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
@@ -136,8 +139,12 @@ module LaunchDarkly
 
     # Returns an instance whose {#kind} is {#FALLTHROUGH}.
     # @return [EvaluationReason]
-    def self.fallthrough
-      @@fallthrough
+    def self.fallthrough(in_experiment=false)
+      if in_experiment
+        @@fallthrough_with_experiment
+      else
+        @@fallthrough
+      end
     end
 
     # Returns an instance whose {#kind} is {#TARGET_MATCH}.
@@ -153,10 +160,16 @@ module LaunchDarkly
     # @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)
+    def self.rule_match(rule_index, rule_id, in_experiment=false)
       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)
+      
+      if in_experiment
+        er = new(:RULE_MATCH, rule_index, rule_id, nil, nil, true)
+      else
+        er = new(:RULE_MATCH, rule_index, rule_id, nil, nil)
+      end
+      er
     end
 
     # Returns an instance whose {#kind} is {#PREREQUISITE_FAILED}.
@@ -204,11 +217,17 @@ module LaunchDarkly
     def inspect
       case @kind
       when :RULE_MATCH
-        "RULE_MATCH(#{@rule_index},#{@rule_id})"
+        if @in_experiment
+          "RULE_MATCH(#{@rule_index},#{@rule_id},#{@in_experiment})"
+        else
+          "RULE_MATCH(#{@rule_index},#{@rule_id})"
+        end
       when :PREREQUISITE_FAILED
         "PREREQUISITE_FAILED(#{@prerequisite_key})"
       when :ERROR
         "ERROR(#{@error_kind})"
+      when :FALLTHROUGH
+        @in_experiment ? "FALLTHROUGH(#{@in_experiment})" : @kind.to_s
       else
         @kind.to_s
       end
@@ -225,11 +244,21 @@ module LaunchDarkly
       # as_json and then modify the result.
       case @kind
       when :RULE_MATCH
-        { kind: @kind, ruleIndex: @rule_index, ruleId: @rule_id }
+        if @in_experiment
+          { kind: @kind, ruleIndex: @rule_index, ruleId: @rule_id, inExperiment: @in_experiment }
+        else
+          { kind: @kind, ruleIndex: @rule_index, ruleId: @rule_id }
+        end
       when :PREREQUISITE_FAILED
         { kind: @kind, prerequisiteKey: @prerequisite_key }
       when :ERROR
         { kind: @kind, errorKind: @error_kind }
+      when :FALLTHROUGH
+        if @in_experiment
+          { kind: @kind, inExperiment: @in_experiment }
+        else
+          { kind: @kind }
+        end
       else
         { kind: @kind }
       end
@@ -263,7 +292,7 @@ module LaunchDarkly
 
     private
 
-    def initialize(kind, rule_index, rule_id, prerequisite_key, error_kind)
+    def initialize(kind, rule_index, rule_id, prerequisite_key, error_kind, in_experiment=nil)
       @kind = kind.to_sym
       @rule_index = rule_index
       @rule_id = rule_id
@@ -271,6 +300,7 @@ module LaunchDarkly
       @prerequisite_key = prerequisite_key
       @prerequisite_key.freeze if !prerequisite_key.nil?
       @error_kind = error_kind
+      @in_experiment = in_experiment
     end
 
     private_class_method :new
@@ -279,6 +309,7 @@ module LaunchDarkly
       new(:ERROR, nil, nil, nil, error_kind)
     end
 
+    @@fallthrough_with_experiment = new(:FALLTHROUGH, nil, nil, nil, nil, true)
     @@fallthrough = new(:FALLTHROUGH, nil, nil, nil, nil)
     @@off = new(:OFF, nil, nil, nil, nil)
     @@target_match = new(:TARGET_MATCH, nil, nil, nil, nil)

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

@@ -190,7 +190,7 @@ module LaunchDarkly
         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)
+        bucket = EvaluatorBucketing.bucket_user(user, segment_key, rule[:bucketBy].nil? ? "key" : rule[:bucketBy], salt, nil)
         weight = rule[:weight].to_f / 100000.0
         return bucket < weight
       end
@@ -213,7 +213,13 @@ module LaunchDarkly
       end
 
       def get_value_for_variation_or_rollout(flag, vr, user, reason)
-        index = EvaluatorBucketing.variation_index_for_user(flag, vr, user)
+        index, in_experiment = EvaluatorBucketing.variation_index_for_user(flag, vr, user)
+        #if in experiment is true, set reason to a different reason instance/singleton with in_experiment set
+        if in_experiment && reason.kind == :FALLTHROUGH
+          reason = EvaluationReason::fallthrough(in_experiment)
+        elsif in_experiment && reason.kind == :RULE_MATCH
+          reason = EvaluationReason::rule_match(reason.rule_index, reason.rule_id, in_experiment)
+        end
         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)

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

@@ -10,20 +10,26 @@ module LaunchDarkly
       # @param user [Object] the user properties
       # @return [Number] the variation index, or nil if there is an error
       def self.variation_index_for_user(flag, rule, user)
+
         variation = rule[:variation]
-        return variation if !variation.nil? # fixed variation
+        return variation, false if !variation.nil? # fixed variation
         rollout = rule[:rollout]
-        return nil if rollout.nil?
+        return nil, false if rollout.nil?
         variations = rollout[:variations]
         if !variations.nil? && variations.length > 0 # percentage rollout
-          rollout = rule[:rollout]
           bucket_by = rollout[:bucketBy].nil? ? "key" : rollout[:bucketBy]
-          bucket = bucket_user(user, flag[:key], bucket_by, flag[:salt])
+
+          seed = rollout[:seed]
+          bucket = bucket_user(user, flag[:key], bucket_by, flag[:salt], seed) # may not be present
           sum = 0;
           variations.each do |variate|
+            if rollout[:kind] == "experiment" && !variate[:untracked]
+              in_experiment = true
+            end
+
             sum += variate[:weight].to_f / 100000.0
             if bucket < sum
-              return variate[:variation]
+              return variate[:variation], !!in_experiment
             end
           end
           # The user's bucket value was greater than or equal to the end of the last bucket. This could happen due
@@ -31,9 +37,12 @@ module LaunchDarkly
           # data could contain buckets that don't actually add up to 100000. Rather than returning an error in
           # this case (or changing the scaling, which would potentially change the results for *all* users), we
           # will simply put the user in the last bucket.
-          variations[-1][:variation]
+          last_variation = variations[-1]
+          in_experiment = rollout[:kind] == "experiment" && !last_variation[:untracked]
+
+          [last_variation[:variation], in_experiment]
         else # the rule isn't well-formed
-          nil
+          [nil, false]
         end
       end
 
@@ -44,7 +53,7 @@ module LaunchDarkly
       # @param bucket_by [String|Symbol] the name of the user attribute to be used for bucketing
       # @param salt [String] the feature flag's or segment's salt value
       # @return [Number] the bucket value, from 0 inclusive to 1 exclusive
-      def self.bucket_user(user, key, bucket_by, salt)
+      def self.bucket_user(user, key, bucket_by, salt, seed)
         return nil unless user[:key]
 
         id_hash = bucketable_string_value(EvaluatorOperators.user_value(user, bucket_by))
@@ -56,7 +65,11 @@ module LaunchDarkly
           id_hash += "." + user[:secondary].to_s
         end
 
-        hash_key = "%s.%s.%s" % [key, salt, id_hash]
+        if seed
+          hash_key = "%d.%s" % [seed, id_hash]
+        else
+          hash_key = "%s.%s.%s" % [key, salt, id_hash]
+        end
 
         hash_val = (Digest::SHA1.hexdigest(hash_key))[0..14]
         hash_val.to_i(16) / Float(0xFFFFFFFFFFFFFFF)

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

@@ -103,6 +103,11 @@ module LaunchDarkly
 
       def is_experiment(flag, reason)
         return false if !reason
+
+        if reason.in_experiment
+          return true
+        end
+
         case reason[:kind]
         when 'RULE_MATCH'
           index = reason[:ruleIndex]
@@ -115,6 +120,7 @@ module LaunchDarkly
         end
         false
       end
+
     end
   end
 end

data/lib/ldclient-rb/version.rb

@@ -1,3 +1,3 @@
 module LaunchDarkly
-  VERSION = "6.1.1"
+  VERSION = "6.2.0"
 end

data/spec/impl/evaluator_bucketing_spec.rb

@@ -4,17 +4,58 @@ describe LaunchDarkly::Impl::EvaluatorBucketing do
   subject { LaunchDarkly::Impl::EvaluatorBucketing }
 
   describe "bucket_user" do
+    describe "seed exists" do
+      let(:seed) { 61 }
+      it "returns the expected bucket values for seed" do
+        user = { key: "userKeyA" }
+        bucket = subject.bucket_user(user, "hashKey", "key", "saltyA", seed)
+        expect(bucket).to be_within(0.0000001).of(0.09801207);
+
+        user = { key: "userKeyB" }
+        bucket = subject.bucket_user(user, "hashKey", "key", "saltyA", seed)
+        expect(bucket).to be_within(0.0000001).of(0.14483777);
+
+        user = { key: "userKeyC" }
+        bucket = subject.bucket_user(user, "hashKey", "key", "saltyA", seed)
+        expect(bucket).to be_within(0.0000001).of(0.9242641);
+      end
+
+      it "returns the same bucket regardless of hashKey and salt" do
+        user = { key: "userKeyA" }
+        bucket1 = subject.bucket_user(user, "hashKey", "key", "saltyA", seed)
+        bucket2 = subject.bucket_user(user, "hashKey1", "key", "saltyB", seed)
+        bucket3 = subject.bucket_user(user, "hashKey2", "key", "saltyC", seed)
+        expect(bucket1).to eq(bucket2)
+        expect(bucket2).to eq(bucket3)
+      end
+
+      it "returns a different bucket if the seed is not the same" do
+        user = { key: "userKeyA" }
+        bucket1 = subject.bucket_user(user, "hashKey", "key", "saltyA", seed)
+        bucket2 = subject.bucket_user(user, "hashKey1", "key", "saltyB", seed+1)
+        expect(bucket1).to_not eq(bucket2)
+      end
+
+      it "returns a different bucket if the user is not the same" do
+        user1 = { key: "userKeyA" }
+        user2 = { key: "userKeyB" }
+        bucket1 = subject.bucket_user(user1, "hashKey", "key", "saltyA", seed)
+        bucket2 = subject.bucket_user(user2, "hashKey1", "key", "saltyB", seed)
+        expect(bucket1).to_not eq(bucket2)
+      end
+    end
+
     it "gets expected bucket values for specific keys" do
       user = { key: "userKeyA" }
-      bucket = subject.bucket_user(user, "hashKey", "key", "saltyA")
+      bucket = subject.bucket_user(user, "hashKey", "key", "saltyA", nil)
       expect(bucket).to be_within(0.0000001).of(0.42157587);
 
       user = { key: "userKeyB" }
-      bucket = subject.bucket_user(user, "hashKey", "key", "saltyA")
+      bucket = subject.bucket_user(user, "hashKey", "key", "saltyA", nil)
       expect(bucket).to be_within(0.0000001).of(0.6708485);
 
       user = { key: "userKeyC" }
-      bucket = subject.bucket_user(user, "hashKey", "key", "saltyA")
+      bucket = subject.bucket_user(user, "hashKey", "key", "saltyA", nil)
       expect(bucket).to be_within(0.0000001).of(0.10343106);
     end
 
@@ -26,8 +67,8 @@ describe LaunchDarkly::Impl::EvaluatorBucketing do
           intAttr: 33333
         }
       }
-      stringResult = subject.bucket_user(user, "hashKey", "stringAttr", "saltyA")
-      intResult = subject.bucket_user(user, "hashKey", "intAttr", "saltyA")
+      stringResult = subject.bucket_user(user, "hashKey", "stringAttr", "saltyA", nil)
+      intResult = subject.bucket_user(user, "hashKey", "intAttr", "saltyA", nil)
 
       expect(intResult).to be_within(0.0000001).of(0.54771423)
       expect(intResult).to eq(stringResult)
@@ -40,7 +81,7 @@ describe LaunchDarkly::Impl::EvaluatorBucketing do
           floatAttr: 33.5
         }
       }
-      result = subject.bucket_user(user, "hashKey", "floatAttr", "saltyA")
+      result = subject.bucket_user(user, "hashKey", "floatAttr", "saltyA", nil)
       expect(result).to eq(0.0)
     end
 
@@ -52,60 +93,124 @@ describe LaunchDarkly::Impl::EvaluatorBucketing do
           boolAttr: true
         }
       }
-      result = subject.bucket_user(user, "hashKey", "boolAttr", "saltyA")
+      result = subject.bucket_user(user, "hashKey", "boolAttr", "saltyA", nil)
       expect(result).to eq(0.0)
     end
   end
 
   describe "variation_index_for_user" do
-    it "matches bucket" do
-      user = { key: "userkey" }
+    context "rollout is not an experiment" do
+      it "matches bucket" do
+        user = { key: "userkey" }
+        flag_key = "flagkey"
+        salt = "salt"
+
+        # First verify that with our test inputs, the bucket value will be greater than zero and less than 100000,
+        # so we can construct a rollout whose second bucket just barely contains that value
+        bucket_value = (subject.bucket_user(user, flag_key, "key", salt, nil) * 100000).truncate()
+        expect(bucket_value).to be > 0
+        expect(bucket_value).to be < 100000
+
+        bad_variation_a = 0
+        matched_variation = 1
+        bad_variation_b = 2
+        rule = {
+          rollout: {
+            variations: [
+              { variation: bad_variation_a, weight: bucket_value }, # end of bucket range is not inclusive, so it will *not* match the target value
+              { variation: matched_variation, weight: 1 }, # size of this bucket is 1, so it only matches that specific value
+              { variation: bad_variation_b, weight: 100000 - (bucket_value + 1) }
+            ]
+          }
+        }
+        flag = { key: flag_key, salt: salt }
+
+        result_variation, inExperiment = subject.variation_index_for_user(flag, rule, user)
+        expect(result_variation).to be matched_variation
+        expect(inExperiment).to be(false)
+      end
+
+      it "uses last bucket if bucket value is equal to total weight" do
+        user = { key: "userkey" }
+        flag_key = "flagkey"
+        salt = "salt"
+
+        bucket_value = (subject.bucket_user(user, flag_key, "key", salt, nil) * 100000).truncate()
+
+        # We'll construct a list of variations that stops right at the target bucket value
+        rule = {
+          rollout: {
+            variations: [
+              { variation: 0, weight: bucket_value }
+            ]
+          }
+        }
+        flag = { key: flag_key, salt: salt }
+
+        result_variation, inExperiment = subject.variation_index_for_user(flag, rule, user)
+        expect(result_variation).to be 0
+        expect(inExperiment).to be(false)
+      end
+    end
+  end
+
+  context "rollout is an experiment" do
+    it "returns whether user is in the experiment or not" do
+      user1 = { key: "userKeyA" }
+      user2 = { key: "userKeyB" }
+      user3 = { key: "userKeyC" }
       flag_key = "flagkey"
       salt = "salt"
+      seed = 61
 
-      # First verify that with our test inputs, the bucket value will be greater than zero and less than 100000,
-      # so we can construct a rollout whose second bucket just barely contains that value
-      bucket_value = (subject.bucket_user(user, flag_key, "key", salt) * 100000).truncate()
-      expect(bucket_value).to be > 0
-      expect(bucket_value).to be < 100000
-
-      bad_variation_a = 0
-      matched_variation = 1
-      bad_variation_b = 2
+    
       rule = {
         rollout: {
+          seed: seed,
+          kind: 'experiment',
           variations: [
-            { variation: bad_variation_a, weight: bucket_value }, # end of bucket range is not inclusive, so it will *not* match the target value
-            { variation: matched_variation, weight: 1 }, # size of this bucket is 1, so it only matches that specific value
-            { variation: bad_variation_b, weight: 100000 - (bucket_value + 1) }
+            { variation: 0, weight: 10000, untracked: false },
+            { variation: 2, weight: 20000, untracked: false },
+            { variation: 0, weight: 70000 , untracked: true }
           ]
         }
       }
       flag = { key: flag_key, salt: salt }
 
-      result_variation = subject.variation_index_for_user(flag, rule, user)
-      expect(result_variation).to be matched_variation
+      result_variation, inExperiment = subject.variation_index_for_user(flag, rule, user1)
+      expect(result_variation).to be(0)
+      expect(inExperiment).to be(true)
+      result_variation, inExperiment = subject.variation_index_for_user(flag, rule, user2)
+      expect(result_variation).to be(2)
+      expect(inExperiment).to be(true)
+      result_variation, inExperiment = subject.variation_index_for_user(flag, rule, user3)
+      expect(result_variation).to be(0)
+      expect(inExperiment).to be(false)
     end
 
     it "uses last bucket if bucket value is equal to total weight" do
       user = { key: "userkey" }
       flag_key = "flagkey"
       salt = "salt"
+      seed = 61
 
-      bucket_value = (subject.bucket_user(user, flag_key, "key", salt) * 100000).truncate()
+      bucket_value = (subject.bucket_user(user, flag_key, "key", salt, seed) * 100000).truncate()
 
       # We'll construct a list of variations that stops right at the target bucket value
       rule = {
         rollout: {
+          seed: seed,
+          kind: 'experiment',
           variations: [
-            { variation: 0, weight: bucket_value }
+            { variation: 0, weight: bucket_value, untracked: false }
           ]
         }
       }
       flag = { key: flag_key, salt: salt }
 
-      result_variation = subject.variation_index_for_user(flag, rule, user)
+      result_variation, inExperiment = subject.variation_index_for_user(flag, rule, user)
       expect(result_variation).to be 0
+      expect(inExperiment).to be(true)
     end
   end
 end

data/spec/impl/evaluator_rule_spec.rb

@@ -91,6 +91,38 @@ module LaunchDarkly
         result = basic_evaluator.evaluate(flag, user, factory)
         expect(result.detail.reason).to eq(EvaluationReason::rule_match(0, 'ruleid'))
       end
+
+      describe "experiment rollout behavior" do
+        it "sets the in_experiment value if rollout kind is experiment " do
+          rule = { id: 'ruleid', clauses: [{ attribute: 'key', op: 'in', values: ['userkey'] }],
+            rollout: { kind: 'experiment', variations: [ { weight: 100000, variation: 1, untracked: false } ] } }
+          flag = boolean_flag_with_rules([rule])
+          user = { key: "userkey", secondary: 999 }
+          result = basic_evaluator.evaluate(flag, user, factory)
+          expect(result.detail.reason.to_json).to include('"inExperiment":true')
+          expect(result.detail.reason.in_experiment).to eq(true)
+        end
+
+        it "does not set the in_experiment value if rollout kind is not experiment " do
+          rule = { id: 'ruleid', clauses: [{ attribute: 'key', op: 'in', values: ['userkey'] }],
+            rollout: { kind: 'rollout', variations: [ { weight: 100000, variation: 1, untracked: false } ] } }
+          flag = boolean_flag_with_rules([rule])
+          user = { key: "userkey", secondary: 999 }
+          result = basic_evaluator.evaluate(flag, user, factory)
+          expect(result.detail.reason.to_json).to_not include('"inExperiment":true')
+          expect(result.detail.reason.in_experiment).to eq(nil)
+        end
+
+        it "does not set the in_experiment value if rollout kind is experiment and untracked is true" do
+          rule = { id: 'ruleid', clauses: [{ attribute: 'key', op: 'in', values: ['userkey'] }],
+            rollout: { kind: 'experiment', variations: [ { weight: 100000, variation: 1, untracked: true } ] } }
+          flag = boolean_flag_with_rules([rule])
+          user = { key: "userkey", secondary: 999 }
+          result = basic_evaluator.evaluate(flag, user, factory)
+          expect(result.detail.reason.to_json).to_not include('"inExperiment":true')
+          expect(result.detail.reason.in_experiment).to eq(nil)
+        end
+      end
     end
   end
 end

data/spec/impl/evaluator_spec.rb

@@ -299,6 +299,50 @@ module LaunchDarkly
           expect(result.detail).to eq(detail)
           expect(result.events).to eq(nil)
         end
+
+        describe "experiment rollout behavior" do
+          it "sets the in_experiment value if rollout kind is experiment and untracked false" do
+            flag = {
+              key: 'feature',
+              on: true,
+              fallthrough: { rollout: { kind: 'experiment', variations: [ { weight: 100000, variation: 1, untracked: false } ]  } },
+              offVariation: 1,
+              variations: ['a', 'b', 'c']
+            }
+            user = { key: 'userkey' }
+            result = basic_evaluator.evaluate(flag, user, factory)
+            expect(result.detail.reason.to_json).to include('"inExperiment":true')
+            expect(result.detail.reason.in_experiment).to eq(true)
+          end
+
+          it "does not set the in_experiment value if rollout kind is not experiment" do
+            flag = {
+              key: 'feature',
+              on: true,
+              fallthrough: { rollout: { kind: 'rollout', variations: [ { weight: 100000, variation: 1, untracked: false } ]  } },
+              offVariation: 1,
+              variations: ['a', 'b', 'c']
+            }
+            user = { key: 'userkey' }
+            result = basic_evaluator.evaluate(flag, user, factory)
+            expect(result.detail.reason.to_json).to_not include('"inExperiment":true')
+            expect(result.detail.reason.in_experiment).to eq(nil)
+          end
+
+          it "does not set the in_experiment value if rollout kind is experiment and untracked is true" do
+            flag = {
+              key: 'feature',
+              on: true,
+              fallthrough: { rollout: { kind: 'experiment', variations: [ { weight: 100000, variation: 1, untracked: true } ]  } },
+              offVariation: 1,
+              variations: ['a', 'b', 'c']
+            }
+            user = { key: 'userkey' }
+            result = basic_evaluator.evaluate(flag, user, factory)
+            expect(result.detail.reason.to_json).to_not include('"inExperiment":true')
+            expect(result.detail.reason.in_experiment).to eq(nil)
+          end
+        end
       end
     end
   end

data/spec/impl/event_factory_spec.rb

@@ -0,0 +1,108 @@
+require "spec_helper"
+
+describe LaunchDarkly::Impl::EventFactory do
+  subject { LaunchDarkly::Impl::EventFactory }
+
+  describe "#new_eval_event" do
+    let(:event_factory_without_reason) { subject.new(false) }
+    let(:user) { { 'key': 'userA' } }
+    let(:rule_with_experiment_rollout) { 
+      { id: 'ruleid',
+        clauses: [{ attribute: 'key', op: 'in', values: ['userkey'] }],
+        trackEvents: false,
+        rollout: { kind: 'experiment', salt: '', variations: [ { weight: 100000, variation: 0, untracked: false } ] }
+      }
+    }
+
+    let(:rule_with_rollout) { 
+      { id: 'ruleid',
+        trackEvents: false,
+        clauses: [{ attribute: 'key', op: 'in', values: ['userkey'] }],
+        rollout: { salt: '', variations: [ { weight: 100000, variation: 0, untracked: false } ] }
+      }
+    }
+
+    let(:fallthrough_with_rollout) {
+      { rollout: { kind: 'rollout', salt: '', variations: [ { weight: 100000, variation: 0, untracked: false } ], trackEventsFallthrough: false } }
+    }
+
+    let(:rule_reason) { LaunchDarkly::EvaluationReason::rule_match(0, 'ruleid') }
+    let(:rule_reason_with_experiment) { LaunchDarkly::EvaluationReason::rule_match(0, 'ruleid', true) }
+    let(:fallthrough_reason) { LaunchDarkly::EvaluationReason::fallthrough }
+    let(:fallthrough_reason_with_experiment) { LaunchDarkly::EvaluationReason::fallthrough(true) }
+
+    context "in_experiment is true" do
+      it "sets the reason and trackevents: true for rules" do
+        flag = createFlag('rule', rule_with_experiment_rollout)
+        detail = LaunchDarkly::EvaluationDetail.new(true, 0, rule_reason_with_experiment)
+        r = subject.new(false).new_eval_event(flag, user, detail, nil, nil)
+        expect(r[:trackEvents]).to eql(true)
+        expect(r[:reason].to_s).to eql("RULE_MATCH(0,ruleid,true)")
+      end
+
+      it "sets the reason and trackevents: true for the fallthrough" do
+        fallthrough_with_rollout[:kind] = 'experiment'
+        flag = createFlag('fallthrough', fallthrough_with_rollout)
+        detail = LaunchDarkly::EvaluationDetail.new(true, 0, fallthrough_reason_with_experiment)
+        r = subject.new(false).new_eval_event(flag, user, detail, nil, nil)
+        expect(r[:trackEvents]).to eql(true)
+        expect(r[:reason].to_s).to eql("FALLTHROUGH(true)")
+      end
+    end
+
+    context "in_experiment is false" do
+      it "sets the reason & trackEvents: true if rule has trackEvents set to true" do
+        rule_with_rollout[:trackEvents] = true
+        flag = createFlag('rule', rule_with_rollout)
+        detail = LaunchDarkly::EvaluationDetail.new(true, 0, rule_reason)
+        r = subject.new(false).new_eval_event(flag, user, detail, nil, nil)
+        expect(r[:trackEvents]).to eql(true)
+        expect(r[:reason].to_s).to eql("RULE_MATCH(0,ruleid)")
+      end
+
+      it "sets the reason & trackEvents: true if fallthrough has trackEventsFallthrough set to true" do
+        flag = createFlag('fallthrough', fallthrough_with_rollout)
+        flag[:trackEventsFallthrough] = true
+        detail = LaunchDarkly::EvaluationDetail.new(true, 0, fallthrough_reason)
+        r = subject.new(false).new_eval_event(flag, user, detail, nil, nil)
+        expect(r[:trackEvents]).to eql(true)
+        expect(r[:reason].to_s).to eql("FALLTHROUGH")
+      end
+
+      it "doesn't set the reason & trackEvents if rule has trackEvents set to false" do
+        flag = createFlag('rule', rule_with_rollout)
+        detail = LaunchDarkly::EvaluationDetail.new(true, 0, rule_reason)
+        r = subject.new(false).new_eval_event(flag, user, detail, nil, nil)
+        expect(r[:trackEvents]).to be_nil
+        expect(r[:reason]).to be_nil
+      end
+
+      it "doesn't set the reason & trackEvents if fallthrough has trackEventsFallthrough set to false" do
+        flag = createFlag('fallthrough', fallthrough_with_rollout)
+        detail = LaunchDarkly::EvaluationDetail.new(true, 0, fallthrough_reason)
+        r = subject.new(false).new_eval_event(flag, user, detail, nil, nil)
+        expect(r[:trackEvents]).to be_nil
+        expect(r[:reason]).to be_nil
+      end
+
+      it "sets trackEvents true and doesn't set the reason if flag[:trackEvents] = true" do
+        flag = createFlag('fallthrough', fallthrough_with_rollout)
+        flag[:trackEvents] = true
+        detail = LaunchDarkly::EvaluationDetail.new(true, 0, fallthrough_reason)
+        r = subject.new(false).new_eval_event(flag, user, detail, nil, nil)
+        expect(r[:trackEvents]).to eql(true)
+        expect(r[:reason]).to be_nil
+      end
+    end
+  end
+
+  def createFlag(kind, rule)
+    if kind == 'rule'
+      { key: 'feature', on: true, rules: [rule], fallthrough: { variation: 0 }, variations: [ false, true ] }
+    elsif kind == 'fallthrough'
+      { key: 'feature', on: true, fallthrough: rule, variations: [ false, true ] }
+    else
+      { key: 'feature', on: true, fallthrough: { variation: 0 }, variations: [ false, true ] }
+    end
+  end
+end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: launchdarkly-server-sdk
 version: !ruby/object:Gem::Version
-  version: 6.1.1
+  version: 6.2.0
 platform: ruby
 authors:
 - LaunchDarkly
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2021-05-27 00:00:00.000000000 Z
+date: 2021-06-17 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: aws-sdk-dynamodb
@@ -336,6 +336,7 @@ files:
 - spec/impl/evaluator_segment_spec.rb
 - spec/impl/evaluator_spec.rb
 - spec/impl/evaluator_spec_base.rb
+- spec/impl/event_factory_spec.rb
 - spec/impl/model/serialization_spec.rb
 - spec/in_memory_feature_store_spec.rb
 - spec/integrations/consul_feature_store_spec.rb
@@ -402,6 +403,7 @@ test_files:
 - spec/impl/evaluator_segment_spec.rb
 - spec/impl/evaluator_spec.rb
 - spec/impl/evaluator_spec_base.rb
+- spec/impl/event_factory_spec.rb
 - spec/impl/model/serialization_spec.rb
 - spec/in_memory_feature_store_spec.rb
 - spec/integrations/consul_feature_store_spec.rb