launchdarkly-server-sdk 5.8.1 → 6.2.0

data/lib/ldclient-rb/polling.rb

@@ -37,10 +37,7 @@ module LaunchDarkly
     def poll
       all_data = @requestor.request_all_data
       if all_data
-        @config.feature_store.init({
-          FEATURES => all_data[:flags],
-          SEGMENTS => all_data[:segments]
-        })
+        @config.feature_store.init(all_data)
         if @initialized.make_true
           @config.logger.info { "[LDClient] Polling connection initialized" }
           @ready.set

data/lib/ldclient-rb/requestor.rb

@@ -1,6 +1,9 @@
+require "ldclient-rb/impl/model/serialization"
+
 require "concurrent/atomics"
 require "json"
 require "uri"
+require "http"
 
 module LaunchDarkly
   # @private
@@ -22,37 +25,44 @@ module LaunchDarkly
     def initialize(sdk_key, config)
       @sdk_key = sdk_key
       @config = config
-      @client = Util.new_http_client(@config.base_uri, @config)
+      @http_client = LaunchDarkly::Util.new_http_client(config.base_uri, config)
       @cache = @config.cache_store
     end
 
     def request_all_data()
-      make_request("/sdk/latest-all")
+      all_data = JSON.parse(make_request("/sdk/latest-all"), symbolize_names: true)
+      Impl::Model.make_all_store_data(all_data)
     end
     
     def stop
       begin
-        @client.finish
+        @http_client.close
       rescue
       end
     end
 
     private
 
+    def request_single_item(kind, path)
+      Impl::Model.deserialize(kind, make_request(path))
+    end
+
     def make_request(path)
-      @client.start if !@client.started?
       uri = URI(@config.base_uri + path)
-      req = Net::HTTP::Get.new(uri)
-      Impl::Util.default_http_headers(@sdk_key, @config).each { |k, v| req[k] = v }
-      req["Connection"] = "keep-alive"
+      headers = {}
+      Impl::Util.default_http_headers(@sdk_key, @config).each { |k, v| headers[k] = v }
+      headers["Connection"] = "keep-alive"
       cached = @cache.read(uri)
       if !cached.nil?
-        req["If-None-Match"] = cached.etag
+        headers["If-None-Match"] = cached.etag
       end
-      res = @client.request(req)
-      status = res.code.to_i
-      @config.logger.debug { "[LDClient] Got response from uri: #{uri}\n\tstatus code: #{status}\n\theaders: #{res.to_hash}\n\tbody: #{res.body}" }
-
+      response = @http_client.request("GET", uri, {
+        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
       if status == 304 && !cached.nil?
         body = cached.body
       else
@@ -60,11 +70,11 @@ module LaunchDarkly
         if status < 200 || status >= 300
           raise UnexpectedResponseError.new(status)
         end
-        body = fix_encoding(res.body, res["content-type"])
-        etag = res["etag"]
+        body = fix_encoding(body, response.headers["content-type"])
+        etag = response.headers["etag"]
         @cache.write(uri, CacheEntry.new(etag, body)) if !etag.nil?
       end
-      JSON.parse(body, symbolize_names: true)
+      body
     end
 
     def fix_encoding(body, content_type)

data/lib/ldclient-rb/stream.rb

@@ -1,3 +1,5 @@
+require "ldclient-rb/impl/model/serialization"
+
 require "concurrent/atomics"
 require "json"
 require "ld-eventsource"
@@ -44,7 +46,8 @@ module LaunchDarkly
       opts = {
         headers: headers,
         read_timeout: READ_TIMEOUT_SECONDS,
-        logger: @config.logger
+        logger: @config.logger,
+        socket_factory: @config.socket_factory
       }
       log_connection_started
       @es = SSE::Client.new(@config.stream_uri + "/all", **opts) do |conn|
@@ -82,10 +85,8 @@ module LaunchDarkly
       @config.logger.debug { "[LDClient] Stream received #{method} message: #{message.data}" }
       if method == PUT
         message = JSON.parse(message.data, symbolize_names: true)
-        @feature_store.init({
-          FEATURES => message[:data][:flags],
-          SEGMENTS => message[:data][:segments]
-        })
+        all_data = Impl::Model.make_all_store_data(message[:data])
+        @feature_store.init(all_data)
         @initialized.make_true
         @config.logger.info { "[LDClient] Stream initialized" }
         @ready.set
@@ -94,7 +95,9 @@ module LaunchDarkly
         for kind in [FEATURES, SEGMENTS]
           key = key_for_path(kind, data[:path])
           if key
-            @feature_store.upsert(kind, data[:data])
+            data = data[:data]
+            Impl::Model.postprocess_item_after_deserializing!(kind, data)
+            @feature_store.upsert(kind, data)
             break
           end
         end

data/lib/ldclient-rb/util.rb

@@ -1,5 +1,5 @@
-require "net/http"
 require "uri"
+require "http"
 
 module LaunchDarkly
   # @private
@@ -18,14 +18,18 @@ module LaunchDarkly
       end
       ret
     end
-
+    
     def self.new_http_client(uri_s, config)
-      uri = URI(uri_s)
-      client = Net::HTTP.new(uri.hostname, uri.port)
-      client.use_ssl = true if uri.scheme == "https"
-      client.open_timeout = config.connect_timeout
-      client.read_timeout = config.read_timeout
-      client
+      http_client_options = {}
+      if config.socket_factory
+        http_client_options["socket_class"] = config.socket_factory
+      end
+      return HTTP::Client.new(http_client_options)
+        .timeout({
+          read: config.read_timeout,
+          connect: config.connect_timeout
+        })
+        .persistent(uri_s)
     end
 
     def self.log_exception(logger, message, exc)

data/lib/ldclient-rb/version.rb

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

data/spec/evaluation_detail_spec.rb

@@ -0,0 +1,135 @@
+require "spec_helper"
+
+module LaunchDarkly
+  describe "EvaluationDetail" do
+    subject { EvaluationDetail }
+
+    it "sets properties" do
+      expect(EvaluationDetail.new("x", 0, EvaluationReason::off).value).to eq "x"
+      expect(EvaluationDetail.new("x", 0, EvaluationReason::off).variation_index).to eq 0
+      expect(EvaluationDetail.new("x", 0, EvaluationReason::off).reason).to eq EvaluationReason::off
+    end
+
+    it "checks parameter types" do
+      expect { EvaluationDetail.new(nil, nil, EvaluationReason::off) }.not_to raise_error
+      expect { EvaluationDetail.new(nil, 0, EvaluationReason::off) }.not_to raise_error
+      expect { EvaluationDetail.new(nil, "x", EvaluationReason::off) }.to raise_error(ArgumentError)
+      expect { EvaluationDetail.new(nil, 0, { kind: "OFF" }) }.to raise_error(ArgumentError)
+      expect { EvaluationDetail.new(nil, 0, nil) }.to raise_error(ArgumentError)
+    end
+
+    it "equality test" do
+      expect(EvaluationDetail.new("x", 0, EvaluationReason::off)).to eq EvaluationDetail.new("x", 0, EvaluationReason::off)
+      expect(EvaluationDetail.new("x", 0, EvaluationReason::off)).not_to eq EvaluationDetail.new("y", 0, EvaluationReason::off)
+      expect(EvaluationDetail.new("x", 0, EvaluationReason::off)).not_to eq EvaluationDetail.new("x", 1, EvaluationReason::off)
+      expect(EvaluationDetail.new("x", 0, EvaluationReason::off)).not_to eq EvaluationDetail.new("x", 0, EvaluationReason::fallthrough)
+    end
+  end
+
+  describe "EvaluationReason" do
+    subject { EvaluationReason }
+
+    values = [
+      [ EvaluationReason::off, EvaluationReason::OFF, { "kind" => "OFF" }, "OFF", nil ],
+      [ EvaluationReason::fallthrough, EvaluationReason::FALLTHROUGH,
+        { "kind" => "FALLTHROUGH" }, "FALLTHROUGH", nil ],
+      [ EvaluationReason::target_match, EvaluationReason::TARGET_MATCH,
+        { "kind" => "TARGET_MATCH" }, "TARGET_MATCH", nil ],
+      [ EvaluationReason::rule_match(1, "x"), EvaluationReason::RULE_MATCH,
+        { "kind" => "RULE_MATCH", "ruleIndex" => 1, "ruleId" => "x" }, "RULE_MATCH(1,x)",
+        [ EvaluationReason::rule_match(2, "x"), EvaluationReason::rule_match(1, "y") ] ],
+      [ EvaluationReason::prerequisite_failed("x"), EvaluationReason::PREREQUISITE_FAILED,
+        { "kind" => "PREREQUISITE_FAILED", "prerequisiteKey" => "x" }, "PREREQUISITE_FAILED(x)" ],
+      [ EvaluationReason::error(EvaluationReason::ERROR_FLAG_NOT_FOUND), EvaluationReason::ERROR,
+        { "kind" => "ERROR", "errorKind" => "FLAG_NOT_FOUND" }, "ERROR(FLAG_NOT_FOUND)" ]
+    ]
+    values.each_index do |i|
+      params = values[i]
+      reason = params[0]
+      kind = params[1]
+      json_rep = params[2]
+      brief_str = params[3]
+      unequal_values = params[4]
+
+      describe "reason #{reason.kind}" do
+        it "has correct kind" do
+          expect(reason.kind).to eq kind
+        end
+
+        it "equality to self" do
+          expect(reason).to eq reason
+        end
+
+        it "inequality to others" do
+          values.each_index do |j|
+            if i != j
+              expect(reason).not_to eq values[j][0]
+            end
+          end
+          if !unequal_values.nil?
+            unequal_values.each do |v|
+              expect(reason).not_to eq v
+            end
+          end
+        end
+
+        it "JSON representation" do
+          expect(JSON.parse(reason.as_json.to_json)).to eq json_rep
+          expect(JSON.parse(reason.to_json)).to eq json_rep
+        end
+
+        it "brief representation" do
+          expect(reason.inspect).to eq brief_str
+          expect(reason.to_s).to eq brief_str
+        end
+      end
+    end
+
+    it "reuses singleton reasons" do
+      expect(EvaluationReason::off).to be EvaluationReason::off
+      expect(EvaluationReason::fallthrough).to be EvaluationReason::fallthrough
+      expect(EvaluationReason::target_match).to be EvaluationReason::target_match
+      expect(EvaluationReason::rule_match(1, 'x')).not_to be EvaluationReason::rule_match(1, 'x')
+      expect(EvaluationReason::prerequisite_failed('x')).not_to be EvaluationReason::prerequisite_failed('x')
+      errors = [ EvaluationReason::ERROR_CLIENT_NOT_READY, EvaluationReason::ERROR_FLAG_NOT_FOUND,
+        EvaluationReason::ERROR_MALFORMED_FLAG, EvaluationReason::ERROR_USER_NOT_SPECIFIED, EvaluationReason::ERROR_EXCEPTION ]
+      errors.each do |e|
+        expect(EvaluationReason::error(e)).to be EvaluationReason::error(e)
+      end
+    end
+
+    it "supports [] with JSON property names" do
+      expect(EvaluationReason::off[:kind]).to eq "OFF"
+      expect(EvaluationReason::off[:ruleIndex]).to be nil
+      expect(EvaluationReason::off[:ruleId]).to be nil
+      expect(EvaluationReason::off[:prerequisiteKey]).to be nil
+      expect(EvaluationReason::off[:errorKind]).to be nil
+      expect(EvaluationReason::rule_match(1, "x")[:ruleIndex]).to eq 1
+      expect(EvaluationReason::rule_match(1, "x")[:ruleId]).to eq "x"
+      expect(EvaluationReason::prerequisite_failed("x")[:prerequisiteKey]).to eq "x"
+      expect(EvaluationReason::error(EvaluationReason::ERROR_FLAG_NOT_FOUND)[:errorKind]).to eq "FLAG_NOT_FOUND"
+    end
+
+    it "freezes string properties" do
+      rm = EvaluationReason::rule_match(1, "x")
+      expect { rm.rule_id.upcase! }.to raise_error(RuntimeError)
+      pf = EvaluationReason::prerequisite_failed("x")
+      expect { pf.prerequisite_key.upcase! }.to raise_error(RuntimeError)
+    end
+
+    it "checks parameter types" do
+      expect { EvaluationReason::rule_match(nil, "x") }.to raise_error(ArgumentError)
+      expect { EvaluationReason::rule_match(true, "x") }.to raise_error(ArgumentError)
+      expect { EvaluationReason::rule_match(1, nil) }.not_to raise_error # we allow nil rule_id for backward compatibility
+      expect { EvaluationReason::rule_match(1, 9) }.to raise_error(ArgumentError)
+      expect { EvaluationReason::prerequisite_failed(nil) }.to raise_error(ArgumentError)
+      expect { EvaluationReason::prerequisite_failed(9) }.to raise_error(ArgumentError)
+      expect { EvaluationReason::error(nil) }.to raise_error(ArgumentError)
+      expect { EvaluationReason::error(9) }.to raise_error(ArgumentError)
+    end
+
+    it "does not allow direct access to constructor" do
+      expect { EvaluationReason.new(:off, nil, nil, nil, nil) }.to raise_error(NoMethodError)
+    end
+  end
+end

data/spec/event_sender_spec.rb

@@ -39,12 +39,29 @@ module LaunchDarkly
             "authorization" => [ sdk_key ],
             "content-type" => [ "application/json" ],
             "user-agent" => [ "RubyClient/" + LaunchDarkly::VERSION ],
-            "x-launchdarkly-event-schema" => [ "3" ]
+            "x-launchdarkly-event-schema" => [ "3" ],
+            "connection" => [ "Keep-Alive" ]
           })
           expect(req.header['x-launchdarkly-payload-id']).not_to eq []
         end
       end
-      
+
+      it "can use a socket factory" do
+        with_server do |server|
+          server.setup_ok_response("/bulk", "")
+
+          config = Config.new(events_uri: "http://events.com/bulk", socket_factory: SocketFactoryFromHash.new({"events.com" => server.port}), logger: $null_log)
+          es = subject.new(sdk_key, config, nil, 0.1)
+
+          result = es.send_event_data(fake_data, "", false)
+
+          expect(result.success).to be true
+          req = server.await_request
+          expect(req.body).to eq fake_data
+          expect(req.host).to eq "events.com"
+        end
+      end
+
       it "generates a new payload ID for each payload" do
         with_sender_and_server do |es, server|
           server.setup_ok_response("/bulk", "")
@@ -78,6 +95,7 @@ module LaunchDarkly
             "authorization" => [ sdk_key ],
             "content-type" => [ "application/json" ],
             "user-agent" => [ "RubyClient/" + LaunchDarkly::VERSION ],
+            "connection" => [ "Keep-Alive" ]
           })
           expect(req.header['x-launchdarkly-event-schema']).to eq []
           expect(req.header['x-launchdarkly-payload-id']).to eq []

data/spec/events_spec.rb

@@ -408,6 +408,16 @@ describe LaunchDarkly::EventProcessor do
     end
   end
 
+  it "queues alias event" do
+    with_processor_and_sender(default_config) do |ep, sender|
+      e = { kind: "alias", key: "a", contextKind: "user", previousKey: "b", previousContextKind: "user" }
+      ep.add_event(e)
+
+      output = flush_and_get_events(ep, sender)
+      expect(output).to contain_exactly(e)
+    end
+  end
+
   it "treats nil value for custom the same as an empty hash" do
     with_processor_and_sender(default_config) do |ep, sender|
       user_with_nil_custom = { key: "userkey", custom: nil }

data/spec/http_util.rb

@@ -3,7 +3,7 @@ require "webrick/httpproxy"
 require "webrick/https"
 
 class StubHTTPServer
-  attr_reader :requests
+  attr_reader :requests, :port
 
   @@next_port = 50000
 
@@ -120,3 +120,13 @@ def with_server(server = nil)
     server.stop
   end
 end
+
+class SocketFactoryFromHash
+  def initialize(ports = {})
+    @ports = ports
+  end
+
+  def open(uri, timeout)
+    TCPSocket.new 'localhost', @ports[uri]
+  end
+end

data/spec/impl/evaluator_bucketing_spec.rb

@@ -0,0 +1,216 @@
+require "spec_helper"
+
+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", nil)
+      expect(bucket).to be_within(0.0000001).of(0.42157587);
+
+      user = { key: "userKeyB" }
+      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", nil)
+      expect(bucket).to be_within(0.0000001).of(0.10343106);
+    end
+
+    it "can bucket by int value (equivalent to string)" do
+      user = {
+        key: "userkey",
+        custom: {
+          stringAttr: "33333",
+          intAttr: 33333
+        }
+      }
+      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)
+    end
+
+    it "cannot bucket by float value" do
+      user = {
+        key: "userkey",
+        custom: {
+          floatAttr: 33.5
+        }
+      }
+      result = subject.bucket_user(user, "hashKey", "floatAttr", "saltyA", nil)
+      expect(result).to eq(0.0)
+    end
+
+
+    it "cannot bucket by bool value" do
+      user = {
+        key: "userkey",
+        custom: {
+          boolAttr: true
+        }
+      }
+      result = subject.bucket_user(user, "hashKey", "boolAttr", "saltyA", nil)
+      expect(result).to eq(0.0)
+    end
+  end
+
+  describe "variation_index_for_user" do
+    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
+
+    
+      rule = {
+        rollout: {
+          seed: seed,
+          kind: 'experiment',
+          variations: [
+            { 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, 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, 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, untracked: false }
+          ]
+        }
+      }
+      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(true)
+    end
+  end
+end