launchdarkly-server-sdk 6.1.0 → 6.2.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 660fcdc21e7d6c74b118c02e180fc0a2a08279d4c936f4d01b45244e2df88732
-  data.tar.gz: 0fc47ce28bb8e66ef1e0c93b06499990366c749adc32250b368d7b25573c971f
+  metadata.gz: eef5d4b08484f02739bfab4d151f5212624cba09157e756e0126603ccacf0a31
+  data.tar.gz: c0510cc29bbb40dd18dc3428803d0b6a33d1c9df868a4ac43caa801c9e3329f0
 SHA512:
-  metadata.gz: 8c93e00623d1e6f954974a3128bd19c31b669eaa440460d1b14c30f4b9581b5aee2c06cf040f2fcbdd815a38384388d3b606c65834ffc4057ade87a083d1eda3
-  data.tar.gz: ef7d3c86a418ab1bb07e3b444107fc92d0472e9fe1a2ed9ef87a57527d72a2c63ce6007ad39dd5ff22f242ea420c4524bb292d8a9e3e18d8ebadb4042d82e1d5
+  metadata.gz: 338a0e3189764f8c5cfe1034ac6602050430a70468da33688953385322c8c94df60919ad04707e7504d6653a51b6928ea0d0fb121518fbdb5fd7ade9e418fa6e
+  data.tar.gz: 94d7650238107eadc7cb2846b826816fe01fe6ee3f421a1a396821681ae8e2b3854c6675bede18cf7a7abf391164123b838dca615bb8404910e07ce350071d02

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.0"
+      LD_RELEASE_VERSION: "6.2.2"
       LD_SKIP_DATABASE_TESTS: "1"
     steps:
       - checkout

data/.github/ISSUE_TEMPLATE/bug_report.md

@@ -8,7 +8,7 @@ assignees: ''
 ---
 
 **Is this a support request?**
-This issue tracker is maintained by LaunchDarkly SDK developers and is intended for feedback on the SDK code. If you're not sure whether the problem you are having is specifically related to the SDK, or to the LaunchDarkly service overall, it may be more appropriate to contact the LaunchDarkly support team; they can help to investigate the problem and will consult the SDK team if necessary. You can submit a support request by going [here](https://support.launchdarkly.com/) and clicking "submit a request", or by emailing support@launchdarkly.com.
+This issue tracker is maintained by LaunchDarkly SDK developers and is intended for feedback on the SDK code. If you're not sure whether the problem you are having is specifically related to the SDK, or to the LaunchDarkly service overall, it may be more appropriate to contact the LaunchDarkly support team; they can help to investigate the problem and will consult the SDK team if necessary. You can submit a support request by going [here](https://support.launchdarkly.com/hc/en-us/requests/new) or by emailing support@launchdarkly.com.
 
 Note that issues filed on this issue tracker are publicly accessible. Do not provide any private account information on your issues. If your problem is specific to your account, you should submit a support request as described above.
 

data/.github/ISSUE_TEMPLATE/config.yml

@@ -0,0 +1,5 @@
+blank_issues_enabled: false
+contact_links:
+  - name: Support request
+    url: https://support.launchdarkly.com/hc/en-us/requests/new
+    about: File your support requests with LaunchDarkly's support team

data/.gitignore

@@ -13,3 +13,4 @@
 mkmf.log
 *.gem
 .DS_Store
+Gemfile.lock

data/CHANGELOG.md

@@ -2,6 +2,23 @@
 
 All notable changes to the LaunchDarkly Ruby SDK will be documented in this file. This project adheres to [Semantic Versioning](http://semver.org).
 
+## [6.2.1] - 2021-07-15
+### Changed:
+- If `variation` or `variation_detail` is called with a user object that has no `key` (an invalid condition that will always result in the default value being returned), the SDK now logs a `warn`-level message to alert you to this incorrect usage. This makes the Ruby SDK's logging behavior consistent with the other server-side LaunchDarkly SDKs. ([#177](https://github.com/launchdarkly/ruby-server-sdk/issues/177))
+
+## [6.2.0] - 2021-06-17
+### Added:
+- The SDK now supports the ability to control the proportion of traffic allocation to an experiment. This works in conjunction with a new platform feature now available to early access customers.
+
+## [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.
+
+
 ## [6.0.0] - 2021-01-26
 ### Added:
 - Added a `socket_factory` configuration option which can be used for socket creation by the HTTP client if provided. The value of `socket_factory` must be an object providing an `open(uri, timeout)` method and returning a connected socket.

data/azure-pipelines.yml

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

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/events.rb

@@ -443,7 +443,7 @@ module LaunchDarkly
         if @inline_users || is_debug
           out[:user] = process_user(event)
         else
-          out[:userKey] = event[:user].nil? ? nil : event[:user][:key]
+          out[:userKey] = event[:user][:key]
         end
         out[:reason] = event[:reason] if !event[:reason].nil?
         out
@@ -451,7 +451,7 @@ module LaunchDarkly
         {
           kind: "identify",
           creationDate: event[:creationDate],
-          key: event[:user].nil? ? nil : event[:user][:key].to_s,
+          key: event[:user][:key].to_s,
           user: process_user(event)
         }
       when "custom"
@@ -464,7 +464,7 @@ module LaunchDarkly
         if @inline_users
           out[:user] = process_user(event)
         else
-          out[:userKey] = event[:user].nil? ? nil : event[:user][:key]
+          out[:userKey] = event[:user][:key]
         end
         out[:metricValue] = event[:metricValue] if event.has_key?(:metricValue)
         out[:contextKind] = event[:contextKind] if event.has_key?(:contextKind)

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/ldclient.rb

@@ -401,6 +401,18 @@ module LaunchDarkly
         return Evaluator.error_result(EvaluationReason::ERROR_CLIENT_NOT_READY, default)
       end
 
+      unless user
+        @config.logger.error { "[LDClient] Must specify user" }
+        detail = Evaluator.error_result(EvaluationReason::ERROR_USER_NOT_SPECIFIED, default)
+        return detail
+      end
+
+      if user[:key].nil?
+        @config.logger.warn { "[LDClient] Variation called with nil user key; returning default value" }
+        detail = Evaluator.error_result(EvaluationReason::ERROR_USER_NOT_SPECIFIED, default)
+        return detail
+      end
+
       if !initialized?
         if @store.initialized?
           @config.logger.warn { "[LDClient] Client has not finished initializing; using last known values from feature store" }
@@ -421,13 +433,6 @@ module LaunchDarkly
         return detail
       end
 
-      unless user
-        @config.logger.error { "[LDClient] Must specify user" }
-        detail = Evaluator.error_result(EvaluationReason::ERROR_USER_NOT_SPECIFIED, default)
-        @event_processor.add_event(event_factory.new_default_event(feature, user, default, detail.reason))
-        return detail
-      end
-
       begin
         res = @evaluator.evaluate(feature, user, event_factory)
         if !res.events.nil?

data/lib/ldclient-rb/requestor.rb

@@ -60,9 +60,9 @@ module LaunchDarkly
         headers: headers
       })
       status = response.status.code
-      @config.logger.debug { "[LDClient] Got response from uri: #{uri}\n\tstatus code: #{status}\n\theaders: #{response.headers}\n\tbody: #{res.to_s}" }
       # must fully read body for persistent connections
       body = response.to_s
+      @config.logger.debug { "[LDClient] Got response from uri: #{uri}\n\tstatus code: #{status}\n\theaders: #{response.headers.to_h}\n\tbody: #{body}" }
       if status == 304 && !cached.nil?
         body = cached.body
       else

data/lib/ldclient-rb/version.rb

@@ -1,3 +1,3 @@
 module LaunchDarkly
-  VERSION = "6.1.0"
+  VERSION = "6.2.2"
 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

data/spec/ldclient_spec.rb

@@ -145,19 +145,11 @@ describe LaunchDarkly::LDClient do
       client.variation("key", user, "default")
     end
 
-    it "queues a feature event for an existing feature when user is nil" do
+    it "does not send an event if user is nil" 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: nil,
-        value: "default",
-        default: "default",
-        trackEvents: true,
-        debugEventsUntilDate: 1000
-      ))
+      expect(event_processor).not_to receive(:add_event)
+      expect(logger).to receive(:error)
       client.variation("key", nil, "default")
     end
 
@@ -179,20 +171,12 @@ describe LaunchDarkly::LDClient do
       client.variation("key", user_anonymous, "default")
     end
 
-    it "queues a feature event for an existing feature when user key is nil" do
+    it "does not queue 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_with_value)
       bad_user = { name: "Bob" }
-      expect(event_processor).to receive(:add_event).with(hash_including(
-        kind: "feature",
-        key: "key",
-        version: 100,
-        user: bad_user,
-        value: "default",
-        default: "default",
-        trackEvents: true,
-        debugEventsUntilDate: 1000
-      ))
+      expect(event_processor).not_to receive(:add_event)
+      expect(logger).to receive(:warn)
       client.variation("key", bad_user, "default")
     end
 
@@ -313,6 +297,14 @@ describe LaunchDarkly::LDClient do
       ))
       client.variation_detail("key", user, "default")
     end
+
+    it "does not send an event if user is nil" do
+      config.feature_store.init({ LaunchDarkly::FEATURES => {} })
+      config.feature_store.upsert(LaunchDarkly::FEATURES, feature_with_value)
+      expect(event_processor).not_to receive(:add_event)
+      expect(logger).to receive(:error)
+      client.variation_detail("key", nil, "default")
+    end
   end
 
   describe '#all_flags' do

data/spec/requestor_spec.rb

@@ -40,6 +40,19 @@ describe LaunchDarkly::Requestor do
       end
     end
 
+    it "logs debug output" do
+      logger = ::Logger.new($stdout)
+      logger.level = ::Logger::DEBUG
+      with_server do |server|
+        with_requestor(server.base_uri.to_s, { logger: logger }) do |requestor|
+          server.setup_ok_response("/", { flags: { x: { key: "y" } } }.to_json)
+          expect do
+            requestor.request_all_data()
+          end.to output(/\[LDClient\] Got response from uri\:/).to_stdout_from_any_process
+        end
+      end
+    end
+
     it "sends etag from previous response" do
       etag = "xyz"
       with_server do |server|

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: launchdarkly-server-sdk
 version: !ruby/object:Gem::Version
-  version: 6.1.0
+  version: 6.2.2
 platform: ruby
 authors:
 - LaunchDarkly
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2021-02-04 00:00:00.000000000 Z
+date: 2021-07-23 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: aws-sdk-dynamodb
@@ -243,6 +243,7 @@ extra_rdoc_files: []
 files:
 - ".circleci/config.yml"
 - ".github/ISSUE_TEMPLATE/bug_report.md"
+- ".github/ISSUE_TEMPLATE/config.yml"
 - ".github/ISSUE_TEMPLATE/feature_request.md"
 - ".github/pull_request_template.md"
 - ".gitignore"
@@ -264,7 +265,6 @@ files:
 - CODEOWNERS
 - CONTRIBUTING.md
 - Gemfile
-- Gemfile.lock
 - LICENSE.txt
 - README.md
 - azure-pipelines.yml
@@ -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

data/Gemfile.lock

@@ -1,116 +0,0 @@
-PATH
-  remote: .
-  specs:
-    launchdarkly-server-sdk (6.1.0)
-      concurrent-ruby (~> 1.1)
-      http (~> 4.4.1)
-      json (~> 2.3.1)
-      ld-eventsource (~> 2.0)
-      semantic (~> 1.6)
-
-GEM
-  remote: https://rubygems.org/
-  specs:
-    addressable (2.7.0)
-      public_suffix (>= 2.0.2, < 5.0)
-    ansi (1.5.0)
-    ast (2.4.2)
-    aws-eventstream (1.1.0)
-    aws-partitions (1.418.0)
-    aws-sdk-core (3.111.2)
-      aws-eventstream (~> 1, >= 1.0.2)
-      aws-partitions (~> 1, >= 1.239.0)
-      aws-sigv4 (~> 1.1)
-      jmespath (~> 1.0)
-    aws-sdk-dynamodb (1.58.0)
-      aws-sdk-core (~> 3, >= 3.109.0)
-      aws-sigv4 (~> 1.1)
-    aws-sigv4 (1.2.2)
-      aws-eventstream (~> 1, >= 1.0.2)
-    concurrent-ruby (1.1.8)
-    connection_pool (2.2.3)
-    deep_merge (1.2.1)
-    diff-lcs (1.4.4)
-    diplomat (2.4.2)
-      deep_merge (~> 1.0, >= 1.0.1)
-      faraday (>= 0.9, < 1.1.0)
-    domain_name (0.5.20190701)
-      unf (>= 0.0.5, < 1.0.0)
-    faraday (1.0.1)
-      multipart-post (>= 1.2, < 3)
-    ffi (1.14.2)
-    ffi-compiler (1.0.1)
-      ffi (>= 1.0.0)
-      rake
-    http (4.4.1)
-      addressable (~> 2.3)
-      http-cookie (~> 1.0)
-      http-form_data (~> 2.2)
-      http-parser (~> 1.2.0)
-    http-cookie (1.0.3)
-      domain_name (~> 0.5)
-    http-form_data (2.3.0)
-    http-parser (1.2.3)
-      ffi-compiler (>= 1.0, < 2.0)
-    jmespath (1.4.0)
-    json (2.3.1)
-    ld-eventsource (2.0.0)
-      concurrent-ruby (~> 1.0)
-      http (~> 4.4.1)
-    listen (3.4.1)
-      rb-fsevent (~> 0.10, >= 0.10.3)
-      rb-inotify (~> 0.9, >= 0.9.10)
-    multipart-post (2.1.1)
-    oga (2.15)
-      ast
-      ruby-ll (~> 2.1)
-    public_suffix (4.0.6)
-    rake (13.0.3)
-    rb-fsevent (0.10.4)
-    rb-inotify (0.10.1)
-      ffi (~> 1.0)
-    redis (4.2.5)
-    rspec (3.10.0)
-      rspec-core (~> 3.10.0)
-      rspec-expectations (~> 3.10.0)
-      rspec-mocks (~> 3.10.0)
-    rspec-core (3.10.1)
-      rspec-support (~> 3.10.0)
-    rspec-expectations (3.10.1)
-      diff-lcs (>= 1.2.0, < 2.0)
-      rspec-support (~> 3.10.0)
-    rspec-mocks (3.10.1)
-      diff-lcs (>= 1.2.0, < 2.0)
-      rspec-support (~> 3.10.0)
-    rspec-support (3.10.1)
-    rspec_junit_formatter (0.4.1)
-      rspec-core (>= 2, < 4, != 2.12.0)
-    ruby-ll (2.1.2)
-      ansi
-      ast
-    semantic (1.6.1)
-    timecop (0.9.2)
-    unf (0.1.4)
-      unf_ext
-    unf_ext (0.0.7.7)
-    webrick (1.7.0)
-
-PLATFORMS
-  ruby
-
-DEPENDENCIES
-  aws-sdk-dynamodb (~> 1.57)
-  bundler (~> 2.1)
-  connection_pool (~> 2.2.3)
-  diplomat (~> 2.4.2)
-  launchdarkly-server-sdk!
-  listen (~> 3.3)
-  oga (~> 2.2)
-  redis (~> 4.2)
-  rspec (~> 3.10)
-  rspec_junit_formatter (~> 0.4)
-  timecop (~> 0.9)
-  webrick (~> 1.7)
-
-BUNDLED WITH
-   2.2.8