ldclient-rb 2.5.0 → 3.0.0

data/lib/ldclient-rb/requestor.rb

@@ -26,6 +26,18 @@ module LaunchDarkly
       make_request("/sdk/latest-flags/" + key)
     end
 
+    def request_all_segments()
+      make_request("/sdk/latest-segments")
+    end
+
+    def request_segment(key)
+      make_request("/sdk/latest-segments/" + key)
+    end
+
+    def request_all_data()
+      make_request("/sdk/latest-all")
+    end
+    
     def make_request(path)
       uri = @config.base_uri + path
       res = @client.get (uri) do |req|

data/lib/ldclient-rb/stream.rb

@@ -10,11 +10,16 @@ module LaunchDarkly
   INDIRECT_PATCH = :'indirect/patch'
   READ_TIMEOUT_SECONDS = 300  # 5 minutes; the stream should send a ping every 3 minutes
 
+  KEY_PATHS = {
+    FEATURES => "/flags/",
+    SEGMENTS => "/segments/"
+  }
+
   class StreamProcessor
     def initialize(sdk_key, config, requestor)
       @sdk_key = sdk_key
       @config = config
-      @store = config.feature_store
+      @feature_store = config.feature_store
       @requestor = requestor
       @initialized = Concurrent::AtomicBoolean.new(false)
       @started = Concurrent::AtomicBoolean.new(false)
@@ -36,7 +41,7 @@ module LaunchDarkly
         'User-Agent' => 'RubyClient/' + LaunchDarkly::VERSION
       }
       opts = {:headers => headers, :with_credentials => true, :proxy => @config.proxy, :read_timeout => READ_TIMEOUT_SECONDS}
-      @es = Celluloid::EventSource.new(@config.stream_uri + "/flags", opts) do |conn|
+      @es = Celluloid::EventSource.new(@config.stream_uri + "/all", opts) do |conn|
         conn.on(PUT) { |message| process_message(message, PUT) }
         conn.on(PATCH) { |message| process_message(message, PATCH) }
         conn.on(DELETE) { |message| process_message(message, DELETE) }
@@ -66,30 +71,61 @@ module LaunchDarkly
       end
     end
 
+    private
+
     def process_message(message, method)
       @config.logger.debug("[LDClient] Stream received #{method} message: #{message.data}")
       if method == PUT
         message = JSON.parse(message.data, symbolize_names: true)
-        @store.init(message)
+        @feature_store.init({
+          FEATURES => message[:data][:flags],
+          SEGMENTS => message[:data][:segments]
+        })
         @initialized.make_true
         @config.logger.info("[LDClient] Stream initialized")
       elsif method == PATCH
         message = JSON.parse(message.data, symbolize_names: true)
-        @store.upsert(message[:path][1..-1], message[:data])
+        for kind in [FEATURES, SEGMENTS]
+          key = key_for_path(kind, message[:path])
+          if key
+            @feature_store.upsert(kind, message[:data])
+            break
+          end
+        end
       elsif method == DELETE
         message = JSON.parse(message.data, symbolize_names: true)
-        @store.delete(message[:path][1..-1], message[:version])
+        for kind in [FEATURES, SEGMENTS]
+          key = key_for_path(kind, message[:path])
+          if key
+            @feature_store.delete(kind, key, message[:version])
+            break
+          end
+        end
       elsif method == INDIRECT_PUT
-        @store.init(@requestor.request_all_flags)
+        all_data = @requestor.request_all_data
+        @feature_store.init({
+          FEATURES => all_data[:flags],
+          SEGMENTS => all_data[:segments]
+        })
         @initialized.make_true
         @config.logger.info("[LDClient] Stream initialized (via indirect message)")
       elsif method == INDIRECT_PATCH
-        @store.upsert(message.data, @requestor.request_flag(message.data))
+        key = feature_key_for_path(message.data)
+        if key
+          @feature_store.upsert(FEATURES, @requestor.request_flag(key))
+        else
+          key = segment_key_for_path(message.data)
+          if key
+            @feature_store.upsert(SEGMENTS, key, @requestor.request_segment(key))
+          end
+        end
       else
         @config.logger.warn("[LDClient] Unknown message received: #{method}")
       end
     end
 
-    private :process_message
+    def key_for_path(kind, path)
+      path.start_with?(KEY_PATHS[kind]) ? path[KEY_PATHS[kind].length..-1] : nil
+    end
   end
 end

data/lib/ldclient-rb/version.rb

@@ -1,3 +1,3 @@
 module LaunchDarkly
-  VERSION = "2.5.0"
+  VERSION = "3.0.0"
 end

data/spec/evaluation_spec.rb

@@ -4,6 +4,14 @@ describe LaunchDarkly::Evaluation do
   subject { LaunchDarkly::Evaluation }
   let(:features) { LaunchDarkly::InMemoryFeatureStore.new }
 
+  let(:user) {
+    {
+      key: "userkey",
+      email: "test@example.com",
+      name: "Bob"
+    }
+  }
+
   include LaunchDarkly::Evaluation
 
   describe "evaluate" do
@@ -60,7 +68,7 @@ describe LaunchDarkly::Evaluation do
         variations: ['d', 'e'],
         version: 2
       }
-      features.upsert('feature1', flag1)
+      features.upsert(LaunchDarkly::FEATURES, flag1)
       user = { key: 'x' }
       events_should_be = [{kind: 'feature', key: 'feature1', value: 'd', version: 2, prereqOf: 'feature0'}]
       expect(evaluate(flag, user, features)).to eq({value: 'b', events: events_should_be})
@@ -83,7 +91,7 @@ describe LaunchDarkly::Evaluation do
         variations: ['d', 'e'],
         version: 2
       }
-      features.upsert('feature1', flag1)
+      features.upsert(LaunchDarkly::FEATURES, flag1)
       user = { key: 'x' }
       events_should_be = [{kind: 'feature', key: 'feature1', value: 'e', version: 2, prereqOf: 'feature0'}]
       expect(evaluate(flag, user, features)).to eq({value: 'a', events: events_should_be})
@@ -133,19 +141,47 @@ describe LaunchDarkly::Evaluation do
     it "can match built-in attribute" do
       user = { key: 'x', name: 'Bob' }
       clause = { attribute: 'name', op: 'in', values: ['Bob'] }
-      expect(clause_match_user(clause, user)).to be true
+      expect(clause_match_user(clause, user, features)).to be true
     end
 
     it "can match custom attribute" do
       user = { key: 'x', name: 'Bob', custom: { legs: 4 } }
       clause = { attribute: 'legs', op: 'in', values: [4] }
-      expect(clause_match_user(clause, user)).to be true
+      expect(clause_match_user(clause, user, features)).to be true
     end
 
     it "returns false for missing attribute" do
       user = { key: 'x', name: 'Bob' }
       clause = { attribute: 'legs', op: 'in', values: [4] }
-      expect(clause_match_user(clause, user)).to be false
+      expect(clause_match_user(clause, user, features)).to be false
+    end
+
+    it "can be negated" do
+      user = { key: 'x', name: 'Bob' }
+      clause = { attribute: 'name', op: 'in', values: ['Bob'], negate: true }
+      expect(clause_match_user(clause, user, features)).to be false
+    end
+
+    it "retrieves segment from segment store for segmentMatch operator" do
+      segment = {
+        key: 'segkey',
+        included: [ 'userkey' ],
+        version: 1,
+        deleted: false
+      }
+      features.upsert(LaunchDarkly::SEGMENTS, segment)
+
+      user = { key: 'userkey' }
+      clause = { attribute: '', op: 'segmentMatch', values: ['segkey'] }
+
+      expect(clause_match_user(clause, user, features)).to be true
+    end
+
+    it "falls through with no errors if referenced segment is not found" do
+      user = { key: 'userkey' }
+      clause = { attribute: '', op: 'segmentMatch', values: ['segkey'] }
+
+      expect(clause_match_user(clause, user, features)).to be false
     end
 
     it "can be negated" do
@@ -153,7 +189,7 @@ describe LaunchDarkly::Evaluation do
       clause = { attribute: 'name', op: 'in', values: ['Bob'] }
       expect {
          clause[:negate] = true
-      }.to change {clause_match_user(clause, user)}.from(true).to(false)
+      }.to change {clause_match_user(clause, user, features)}.from(true).to(false)
     end
   end
 
@@ -255,7 +291,7 @@ describe LaunchDarkly::Evaluation do
       it "should return #{shouldBe} for #{value1} #{op} #{value2}" do
         user = { key: 'x', custom: { foo: value1 } }
         clause = { attribute: 'foo', op: op, values: [value2] }
-        expect(clause_match_user(clause, user)).to be shouldBe
+        expect(clause_match_user(clause, user, features)).to be shouldBe
       end
     end
   end
@@ -313,4 +349,165 @@ describe LaunchDarkly::Evaluation do
       expect(result).to eq(0.0)
     end
   end
+  
+  def make_flag(key)
+    {
+      key: key,
+      rules: [],
+      variations: [ false, true ],
+      on: true,
+      fallthrough: { variation: 0 },
+      version: 1
+    }
+  end
+
+  def make_segment(key)
+    {
+      key: key,
+      included: [],
+      excluded: [],
+      salt: 'abcdef',
+      version: 1
+    }
+  end
+
+  def make_segment_match_clause(segment)
+    {
+      op: :segmentMatch,
+      values: [ segment[:key] ],
+      negate: false
+    }
+  end
+
+  def make_user_matching_clause(user, attr)
+    {
+      attribute: attr.to_s,
+      op: :in,
+      values: [ user[attr.to_sym] ],
+      negate: false
+    }
+  end
+
+  describe 'segment matching' do
+    it 'explicitly includes user' do
+      segment = make_segment('segkey')
+      segment[:included] = [ user[:key] ]
+      features.upsert(LaunchDarkly::SEGMENTS, segment)
+      clause = make_segment_match_clause(segment)
+
+      result = clause_match_user(clause, user, features)
+      expect(result).to be true
+    end
+
+    it 'explicitly excludes user' do
+      segment = make_segment('segkey')
+      segment[:excluded] = [ user[:key] ]
+      features.upsert(LaunchDarkly::SEGMENTS, segment)
+      clause = make_segment_match_clause(segment)
+
+      result = clause_match_user(clause, user, features)
+      expect(result).to be false
+    end
+
+    it 'both includes and excludes user; include takes priority' do
+      segment = make_segment('segkey')
+      segment[:included] = [ user[:key] ]
+      segment[:excluded] = [ user[:key] ]
+      features.upsert(LaunchDarkly::SEGMENTS, segment)
+      clause = make_segment_match_clause(segment)
+
+      result = clause_match_user(clause, user, features)
+      expect(result).to be true
+    end
+
+    it 'matches user by rule when weight is absent' do
+      segClause = make_user_matching_clause(user, :email)
+      segRule = {
+        clauses: [ segClause ]
+      }
+      segment = make_segment('segkey')
+      segment[:rules] = [ segRule ]
+      features.upsert(LaunchDarkly::SEGMENTS, segment)
+      clause = make_segment_match_clause(segment)
+
+      result = clause_match_user(clause, user, features)
+      expect(result).to be true
+    end
+
+    it 'matches user by rule when weight is nil' do
+      segClause = make_user_matching_clause(user, :email)
+      segRule = {
+        clauses: [ segClause ],
+        weight: nil
+      }
+      segment = make_segment('segkey')
+      segment[:rules] = [ segRule ]
+      features.upsert(LaunchDarkly::SEGMENTS, segment)
+      clause = make_segment_match_clause(segment)
+
+      result = clause_match_user(clause, user, features)
+      expect(result).to be true
+    end
+
+    it 'matches user with full rollout' do
+      segClause = make_user_matching_clause(user, :email)
+      segRule = {
+        clauses: [ segClause ],
+        weight: 100000
+      }
+      segment = make_segment('segkey')
+      segment[:rules] = [ segRule ]
+      features.upsert(LaunchDarkly::SEGMENTS, segment)
+      clause = make_segment_match_clause(segment)
+
+      result = clause_match_user(clause, user, features)
+      expect(result).to be true
+    end
+
+    it "doesn't match user with zero rollout" do
+      segClause = make_user_matching_clause(user, :email)
+      segRule = {
+        clauses: [ segClause ],
+        weight: 0
+      }
+      segment = make_segment('segkey')
+      segment[:rules] = [ segRule ]
+      features.upsert(LaunchDarkly::SEGMENTS, segment)
+      clause = make_segment_match_clause(segment)
+
+      result = clause_match_user(clause, user, features)
+      expect(result).to be false
+    end
+
+    it "matches user with multiple clauses" do
+      segClause1 = make_user_matching_clause(user, :email)
+      segClause2 = make_user_matching_clause(user, :name)
+      segRule = {
+        clauses: [ segClause1, segClause2 ]
+      }
+      segment = make_segment('segkey')
+      segment[:rules] = [ segRule ]
+      features.upsert(LaunchDarkly::SEGMENTS, segment)
+      clause = make_segment_match_clause(segment)
+
+      result = clause_match_user(clause, user, features)
+      expect(result).to be true
+    end
+
+    it "doesn't match user with multiple clauses if a clause doesn't match" do
+      segClause1 = make_user_matching_clause(user, :email)
+      segClause2 = make_user_matching_clause(user, :name)
+      segClause2[:values] = [ 'wrong' ]
+      segRule = {
+        clauses: [ segClause1, segClause2 ]
+      }
+      segment = make_segment('segkey')
+      segment[:rules] = [ segRule ]
+      features.upsert(LaunchDarkly::SEGMENTS, segment)
+      clause = make_segment_match_clause(segment)
+
+      result = clause_match_user(clause, user, features)
+      expect(result).to be false
+    end
+  end
 end

data/spec/feature_store_spec_base.rb

@@ -31,7 +31,7 @@ RSpec.shared_examples "feature_store" do |create_store_method|
 
   let!(:store) do
     s = create_store_method.call()
-    s.init({ key0 => feature0 })
+    s.init(LaunchDarkly::FEATURES => { key0 => feature0 })
     s
   end
 
@@ -48,15 +48,15 @@ RSpec.shared_examples "feature_store" do |create_store_method|
   end
 
   it "can get existing feature with symbol key" do
-    expect(store.get(key0)).to eq feature0
+    expect(store.get(LaunchDarkly::FEATURES, key0)).to eq feature0
   end
 
   it "can get existing feature with string key" do
-    expect(store.get(key0.to_s)).to eq feature0
+    expect(store.get(LaunchDarkly::FEATURES, key0.to_s)).to eq feature0
   end
 
   it "gets nil for nonexisting feature" do
-    expect(store.get('nope')).to be_nil
+    expect(store.get(LaunchDarkly::FEATURES, 'nope')).to be_nil
   end
 
   it "can get all features" do
@@ -64,8 +64,8 @@ RSpec.shared_examples "feature_store" do |create_store_method|
     feature1[:key] = "test-feature-flag1"
     feature1[:version] = 5
     feature1[:on] = false
-    store.upsert(:"test-feature-flag1", feature1)
-    expect(store.all).to eq ({ key0 => feature0, :"test-feature-flag1" => feature1 })
+    store.upsert(LaunchDarkly::FEATURES, feature1)
+    expect(store.all(LaunchDarkly::FEATURES)).to eq ({ key0 => feature0, :"test-feature-flag1" => feature1 })
   end
 
   it "can add new feature" do
@@ -73,40 +73,40 @@ RSpec.shared_examples "feature_store" do |create_store_method|
     feature1[:key] = "test-feature-flag1"
     feature1[:version] = 5
     feature1[:on] = false
-    store.upsert(:"test-feature-flag1", feature1)
-    expect(store.get(:"test-feature-flag1")).to eq feature1
+    store.upsert(LaunchDarkly::FEATURES, feature1)
+    expect(store.get(LaunchDarkly::FEATURES, :"test-feature-flag1")).to eq feature1
   end
 
   it "can update feature with newer version" do
     f1 = new_version_plus(feature0, 1, { on: !feature0[:on] })
-    store.upsert(key0, f1)
-    expect(store.get(key0)).to eq f1
+    store.upsert(LaunchDarkly::FEATURES, f1)
+    expect(store.get(LaunchDarkly::FEATURES, key0)).to eq f1
   end
 
   it "cannot update feature with same version" do
     f1 = new_version_plus(feature0, 0, { on: !feature0[:on] })
-    store.upsert(key0, f1)
-    expect(store.get(key0)).to eq feature0
+    store.upsert(LaunchDarkly::FEATURES, f1)
+    expect(store.get(LaunchDarkly::FEATURES, key0)).to eq feature0
   end
 
   it "cannot update feature with older version" do
     f1 = new_version_plus(feature0, -1, { on: !feature0[:on] })
-    store.upsert(key0, f1)
-    expect(store.get(key0)).to eq feature0
+    store.upsert(LaunchDarkly::FEATURES, f1)
+    expect(store.get(LaunchDarkly::FEATURES, key0)).to eq feature0
   end
 
   it "can delete feature with newer version" do
-    store.delete(key0, feature0[:version] + 1)
-    expect(store.get(key0)).to be_nil
+    store.delete(LaunchDarkly::FEATURES, key0, feature0[:version] + 1)
+    expect(store.get(LaunchDarkly::FEATURES, key0)).to be_nil
   end
 
   it "cannot delete feature with same version" do
-    store.delete(key0, feature0[:version])
-    expect(store.get(key0)).to eq feature0
+    store.delete(LaunchDarkly::FEATURES, key0, feature0[:version])
+    expect(store.get(LaunchDarkly::FEATURES, key0)).to eq feature0
   end
 
   it "cannot delete feature with older version" do
-    store.delete(key0, feature0[:version] - 1)
-    expect(store.get(key0)).to eq feature0
+    store.delete(LaunchDarkly::FEATURES, key0, feature0[:version] - 1)
+    expect(store.get(LaunchDarkly::FEATURES, key0)).to eq feature0
   end
 end