launchdarkly-server-sdk 6.1.1 → 6.2.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 631066b2968b323ed2e12aed1565c76cf1f8bb6284e8372121771577b49bda18
-  data.tar.gz: 3e6b7c3b9769c917996e844c598796912f19c20e796692b877a885886d8fa070
+  metadata.gz: 326e10ac69bf7d73c5727c555a2981b7d271d1651d9521b976005d93646a188b
+  data.tar.gz: 608205f6ac545e410aaa9e507180b8ad097ebe1ed23c6dc011b2c522209d9e3f
 SHA512:
-  metadata.gz: 5a885a5714a9cc157e295dd1a88a353a546847a702a771b4edf49f33c081eb19c4141ee7a0b4a8004620c1a4c20ef0111af0c0900ee3a28845f29e2385ebd13c
-  data.tar.gz: 6e604eac4e997431d09257bf97ec115f3a130293e4bc83fa08254baaa921eb28a2230e5bc2bd080c855293e773331e5eed006741db6cd9943132a1f2a1dc243d
+  metadata.gz: a1b648a1d796ad1b65feffd9ee83fcd3dcb63c3146d513e44173d5cb6da32fd29b993d8b7343957094b801b69da5c0873b458fb568e6d174e4c402e158d129c4
+  data.tar.gz: 433d7761a4386538c25a8db6a0520b7d1e8c7184dcc9967e9770bbf5639e3f0a74476f2a0ef20f50bf53a5c6da4df62aacfd444f5fad5cfb1d64bc73a113374f

data/.circleci/config.yml

@@ -20,10 +20,13 @@ 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.4"
       LD_SKIP_DATABASE_TESTS: "1"
     steps:
       - checkout
+      - run:
+          name: "Releaser: prepare"
+          command: .ldrelease/circleci/mac/execute.sh prepare .ldrelease/circleci/template/prepare.sh
       - run:
           name: "Releaser: build"
           command: .ldrelease/circleci/mac/execute.sh build .ldrelease/circleci/template/build.sh

data/.ldrelease/circleci/template/build.sh

@@ -7,20 +7,10 @@ set -ue
 echo "Using gem $(gem --version)"
 
 #shellcheck source=/dev/null
-source "$(dirname "$0")/set-gem-home.sh"
-
-# If the gemspec specifies a certain version of bundler, we need to make sure we install that version.
-echo "Installing bundler"
-GEMSPEC_BUNDLER_VERSION=$(sed -n -e "s/.*['\"]bundler['\"], *['\"]\([^'\"]*\)['\"]/\1/p" ./*.gemspec | tr -d ' ')
-if [ -n "${GEMSPEC_BUNDLER_VERSION}" ]; then
-  GEMSPEC_OPTIONS="-v ${GEMSPEC_BUNDLER_VERSION}"
-else
-  GEMSPEC_OPTIONS=""
-fi
-gem install bundler ${GEMSPEC_OPTIONS} || { echo "installing bundler failed" >&2; exit 1; }
+source "$(dirname "$0")/gems-setup.sh"
 
 echo; echo "Installing dependencies"
-bundle install
+${BUNDLER_COMMAND} install
 
 # Build Ruby Gem - this assumes there is a single .gemspec file in the main project directory
 # Note that the gemspec must be able to get the project version either from $LD_RELEASE_VERSION,

data/.ldrelease/circleci/template/gems-setup.sh

@@ -0,0 +1,16 @@
+#!/bin/bash
+
+# helper script to set GEM_HOME, PATH, and BUNDLER_COMMAND for Ruby - must be sourced, not executed
+
+mkdir -p "${LD_RELEASE_TEMP_DIR}/gems"
+export GEM_HOME="${LD_RELEASE_TEMP_DIR}/gems"
+export PATH="${GEM_HOME}/bin:${PATH}"
+
+# also, determine whether we'll need to run a specific version of Bundler
+
+GEMSPEC_BUNDLER_VERSION=$(sed -n -e "s/.*['\"]bundler['\"], *['\"]\([^'\"]*\)['\"]/\1/p" ./*.gemspec | tr -d ' ')
+if [ -n "${GEMSPEC_BUNDLER_VERSION}" ]; then
+  BUNDLER_COMMAND="bundler _${GEMSPEC_BUNDLER_VERSION}_"
+else
+  BUNDLER_COMMAND="bundler"
+fi

data/.ldrelease/circleci/template/prepare.sh

@@ -0,0 +1,17 @@
+#!/bin/bash
+
+set -ue
+
+echo "Using gem $(gem --version)"
+
+#shellcheck source=/dev/null
+source "$(dirname "$0")/gems-setup.sh"
+
+# If the gemspec specifies a certain version of bundler, we need to make sure we install that version.
+echo "Installing bundler"
+if [ -n "${GEMSPEC_BUNDLER_VERSION:-}" ]; then
+  GEMSPEC_OPTIONS="-v ${GEMSPEC_BUNDLER_VERSION}"
+else
+  GEMSPEC_OPTIONS=""
+fi
+gem install bundler ${GEMSPEC_OPTIONS} || { echo "installing bundler failed" >&2; exit 1; }

data/.ldrelease/circleci/template/publish.sh

@@ -4,17 +4,13 @@ set -ue
 
 # Standard publish.sh for Ruby-based projects - we can assume build.sh has already been run
 
-export GEM_HOME="${LD_RELEASE_TEMP_DIR}/gems"
+#shellcheck source=/dev/null
+source "$(dirname "$0")/gems-setup.sh"
 
 # If we're running in CircleCI, the RubyGems credentials will be in an environment
-# variable and need to be copied to a file
-if [ -n "${LD_RELEASE_RUBYGEMS_API_KEY}" ]; then
-  mkdir -p ~/.gem
-  cat >~/.gem/credentials <<EOF
----
-:rubygems_api_key: $LD_RELEASE_RUBYGEMS_API_KEY
-EOF
-  chmod 0600 ~/.gem/credentials
+# variable and should be copied to the variable the gem command expects
+if [ -n "${LD_RELEASE_RUBYGEMS_API_KEY:-}" ]; then
+  export GEM_HOST_API_KEY="${LD_RELEASE_RUBYGEMS_API_KEY}"
 fi
 
 # Since all Releaser builds are clean builds, we can assume that the only .gem file here

data/.ldrelease/circleci/template/test.sh

@@ -5,6 +5,6 @@ set -ue
 # Standard test.sh for Ruby-based projects
 
 #shellcheck source=/dev/null
-source "$(dirname "$0")/set-gem-home.sh"
+source "$(dirname "$0")/gems-setup.sh"
 
-bundle exec rspec spec
+${BUNDLER_COMMAND} exec rspec spec

data/CHANGELOG.md

@@ -2,6 +2,26 @@
 
 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.3] - 2021-08-06
+### Fixed:
+- Diagnostic events did not properly set the `usingProxy` attribute when a proxy was configured with the `HTTPS_PROXY` environment variable. ([#182](https://github.com/launchdarkly/ruby-server-sdk/issues/182))
+
+## [6.2.2] - 2021-07-23
+### Fixed:
+- Enabling debug logging in polling mode could cause polling to fail with a `NameError`. (Thanks, [mmurphy-notarize](https://github.com/launchdarkly/ruby-server-sdk/pull/180)!)
+
+## [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.

data/launchdarkly-server-sdk.gemspec

@@ -22,7 +22,7 @@ Gem::Specification.new do |spec|
   spec.required_ruby_version = ">= 2.5.0"
 
   spec.add_development_dependency "aws-sdk-dynamodb", "~> 1.57"
-  spec.add_development_dependency "bundler", "~> 2.1"
+  spec.add_development_dependency "bundler", "2.2.10"
   spec.add_development_dependency "rspec", "~> 3.10"
   spec.add_development_dependency "diplomat", "~> 2.4.2"
   spec.add_development_dependency "redis", "~> 4.2"
@@ -36,10 +36,8 @@ Gem::Specification.new do |spec|
 
   spec.add_runtime_dependency "semantic", "~> 1.6"
   spec.add_runtime_dependency "concurrent-ruby", "~> 1.1"
-  spec.add_runtime_dependency "ld-eventsource", "~> 2.0"
+  spec.add_runtime_dependency "ld-eventsource", "2.0.1"
 
-  # lock json to 2.3.x as ruby libraries often remove
-  # support for older ruby versions in minor releases
-  spec.add_runtime_dependency "json", "~> 2.3.1"
-  spec.add_runtime_dependency "http", "~> 4.4.1"
+  spec.add_runtime_dependency "json", "~> 2.3"
+  spec.add_runtime_dependency "http", ">= 4.4.0", "< 6.0.0"
 end

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

@@ -79,7 +79,7 @@ module LaunchDarkly
           streamingDisabled: !config.stream?,
           userKeysCapacity: config.user_keys_capacity,
           userKeysFlushIntervalMillis: self.seconds_to_millis(config.user_keys_flush_interval),
-          usingProxy: ENV.has_key?('http_proxy') || ENV.has_key?('https_proxy') || ENV.has_key?('HTTP_PROXY'),
+          usingProxy: ENV.has_key?('http_proxy') || ENV.has_key?('https_proxy') || ENV.has_key?('HTTP_PROXY') || ENV.has_key?('HTTPS_PROXY'),
           usingRelayDaemon: config.use_ldd?,
         }
         ret

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

@@ -407,6 +407,12 @@ module LaunchDarkly
         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" }

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.1"
+  VERSION = "6.2.4"
 end

data/spec/diagnostic_events_spec.rb

@@ -79,13 +79,15 @@ module LaunchDarkly
           end
         end
 
-        it "detects proxy" do
-          begin
-            ENV["http_proxy"] = 'http://my-proxy'
-            event = default_acc.create_init_event(Config.new)
-            expect(event[:configuration][:usingProxy]).to be true
-          ensure
-            ENV["http_proxy"] = nil
+        ['http_proxy', 'https_proxy', 'HTTP_PROXY', 'HTTPS_PROXY'].each do |name|
+          it "detects proxy #{name}" do
+            begin
+              ENV[name] = 'http://my-proxy'
+              event = default_acc.create_init_event(Config.new)
+              expect(event[:configuration][:usingProxy]).to be true
+            ensure
+              ENV[name] = nil
+            end
           end
         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

@@ -171,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
 

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.1
+  version: 6.2.4
 platform: ruby
 authors:
 - LaunchDarkly
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2021-05-27 00:00:00.000000000 Z
+date: 2021-08-11 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: aws-sdk-dynamodb
@@ -28,16 +28,16 @@ dependencies:
   name: bundler
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - '='
       - !ruby/object:Gem::Version
-        version: '2.1'
+        version: 2.2.10
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - '='
       - !ruby/object:Gem::Version
-        version: '2.1'
+        version: 2.2.10
 - !ruby/object:Gem::Dependency
   name: rspec
   requirement: !ruby/object:Gem::Requirement
@@ -196,44 +196,50 @@ dependencies:
   name: ld-eventsource
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - '='
       - !ruby/object:Gem::Version
-        version: '2.0'
+        version: 2.0.1
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - '='
       - !ruby/object:Gem::Version
-        version: '2.0'
+        version: 2.0.1
 - !ruby/object:Gem::Dependency
   name: json
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 2.3.1
+        version: '2.3'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 2.3.1
+        version: '2.3'
 - !ruby/object:Gem::Dependency
   name: http
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 4.4.0
+    - - "<"
       - !ruby/object:Gem::Version
-        version: 4.4.1
+        version: 6.0.0
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 4.4.0
+    - - "<"
       - !ruby/object:Gem::Version
-        version: 4.4.1
+        version: 6.0.0
 description: Official LaunchDarkly SDK for Ruby
 email:
 - team@launchdarkly.com
@@ -252,8 +258,9 @@ files:
 - ".ldrelease/circleci/linux/execute.sh"
 - ".ldrelease/circleci/mac/execute.sh"
 - ".ldrelease/circleci/template/build.sh"
+- ".ldrelease/circleci/template/gems-setup.sh"
+- ".ldrelease/circleci/template/prepare.sh"
 - ".ldrelease/circleci/template/publish.sh"
-- ".ldrelease/circleci/template/set-gem-home.sh"
 - ".ldrelease/circleci/template/test.sh"
 - ".ldrelease/circleci/template/update-version.sh"
 - ".ldrelease/circleci/windows/execute.ps1"
@@ -336,6 +343,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 +410,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/.ldrelease/circleci/template/set-gem-home.sh

@@ -1,7 +0,0 @@
-#!/bin/bash
-
-# helper script to set GEM_HOME and PATH for Ruby - must be sourced, not executed
-
-mkdir -p "${LD_RELEASE_TEMP_DIR}/gems"
-export GEM_HOME="${LD_RELEASE_TEMP_DIR}/gems"
-export PATH="${GEM_HOME}/bin:${PATH}"