ldclient-rb 3.0.3 → 4.0.0

data/spec/expiring_cache_spec.rb

@@ -0,0 +1,76 @@
+require 'timecop'
+
+describe LaunchDarkly::ExpiringCache do
+  subject { LaunchDarkly::ExpiringCache }
+
+  before(:each) do
+    Timecop.freeze(Time.now)
+  end
+
+  after(:each) do
+    Timecop.return
+  end
+  
+  it "evicts entries based on TTL" do
+    c = subject.new(3, 300)
+    c[:a] = 1
+    c[:b] = 2
+
+    Timecop.freeze(Time.now + 330)
+
+    c[:c] = 3
+
+    expect(c[:a]).to be nil
+    expect(c[:b]).to be nil
+    expect(c[:c]).to eq 3
+  end
+
+  it "evicts entries based on max size" do
+    c = subject.new(2, 300)
+    c[:a] = 1
+    c[:b] = 2
+    c[:c] = 3
+
+    expect(c[:a]).to be nil
+    expect(c[:b]).to eq 2
+    expect(c[:c]).to eq 3
+  end
+
+  it "does not reset LRU on get" do
+    c = subject.new(2, 300)
+    c[:a] = 1
+    c[:b] = 2
+    c[:a]
+    c[:c] = 3
+
+    expect(c[:a]).to be nil
+    expect(c[:b]).to eq 2
+    expect(c[:c]).to eq 3    
+  end
+
+  it "resets LRU on put" do
+    c = subject.new(2, 300)
+    c[:a] = 1
+    c[:b] = 2
+    c[:a] = 1
+    c[:c] = 3
+
+    expect(c[:a]).to eq 1
+    expect(c[:b]).to be nil
+    expect(c[:c]).to eq 3    
+  end
+
+  it "resets TTL on put" do
+    c = subject.new(3, 300)
+    c[:a] = 1
+    c[:b] = 2
+
+    Timecop.freeze(Time.now + 330)
+    c[:a] = 1
+    c[:c] = 3
+
+    expect(c[:a]).to eq 1
+    expect(c[:b]).to be nil
+    expect(c[:c]).to eq 3
+  end
+end

data/spec/fixtures/feature.json

@@ -32,5 +32,6 @@
       true,
       false
    ],
+   "trackEvents": true,
    "deleted":false
 }

data/spec/ldclient_spec.rb

@@ -3,7 +3,12 @@ require "spec_helper"
 
 describe LaunchDarkly::LDClient do
   subject { LaunchDarkly::LDClient }
-  let(:config) { LaunchDarkly::Config.new({offline: true}) }  
+  let(:offline_config) { LaunchDarkly::Config.new({offline: true}) }
+  let(:offline_client) do
+    subject.new("secret", offline_config)
+  end
+  let(:update_processor) { NullUpdateProcessor.new }
+  let(:config) { LaunchDarkly::Config.new({send_events: false, update_processor: update_processor}) }
   let(:client) do
     subject.new("secret", config)
   end
@@ -24,11 +29,74 @@ describe LaunchDarkly::LDClient do
     JSON.parse(data, symbolize_names: true)
   end
 
+  def event_processor
+    client.instance_variable_get(:@event_processor)
+  end
+
   describe '#variation' do
     it "will return the default value if the client is offline" do
-      result = client.variation(feature[:key], user, "default")
+      result = offline_client.variation("doesntmatter", user, "default")
       expect(result).to eq "default"
     end
+
+    it "queues a feature request event for an unknown feature" do
+      expect(event_processor).to receive(:add_event).with(hash_including(
+        kind: "feature", key: "badkey", user: user, value: "default", default: "default"
+      ))
+      client.variation("badkey", user, "default")
+    end
+
+    it "queues a feature request event for an existing feature" do
+      config.feature_store.init({ LaunchDarkly::FEATURES => {} })
+      config.feature_store.upsert(LaunchDarkly::FEATURES, feature)
+      expect(event_processor).to receive(:add_event).with(hash_including(
+        kind: "feature",
+        key: feature[:key],
+        version: feature[:version],
+        user: user,
+        variation: 0,
+        value: true,
+        default: "default",
+        trackEvents: true,
+        debugEventsUntilDate: nil
+      ))
+      client.variation(feature[:key], user, "default")
+    end
+
+    it "queues a feature event for an existing feature when user is nil" do
+      config.feature_store.init({ LaunchDarkly::FEATURES => {} })
+      config.feature_store.upsert(LaunchDarkly::FEATURES, feature)
+      expect(event_processor).to receive(:add_event).with(hash_including(
+        kind: "feature",
+        key: feature[:key],
+        version: feature[:version],
+        user: nil,
+        variation: nil,
+        value: "default",
+        default: "default",
+        trackEvents: true,
+        debugEventsUntilDate: nil
+      ))
+      client.variation(feature[:key], nil, "default")
+    end
+
+    it "queues 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)
+      bad_user = { name: "Bob" }
+      expect(event_processor).to receive(:add_event).with(hash_including(
+        kind: "feature",
+        key: feature[:key],
+        version: feature[:version],
+        user: bad_user,
+        variation: nil,
+        value: "default",
+        default: "default",
+        trackEvents: true,
+        debugEventsUntilDate: nil
+      ))
+      client.variation(feature[:key], bad_user, "default")
+    end
   end
 
   describe '#secure_mode_hash' do
@@ -40,22 +108,24 @@ describe LaunchDarkly::LDClient do
 
   describe '#track' do 
     it "queues up an custom event" do
-      expect(client.instance_variable_get(:@event_processor)).to receive(:add_event).with(hash_including(kind: "custom", key: "custom_event_name", user: user, data: 42))
+      expect(event_processor).to receive(:add_event).with(hash_including(kind: "custom", key: "custom_event_name", user: user, data: 42))
       client.track("custom_event_name", user, 42)
     end
+
     it "sanitizes the user in the event" do
-      expect(client.instance_variable_get(:@event_processor)).to receive(:add_event).with(hash_including(user: sanitized_numeric_key_user))
+      expect(event_processor).to receive(:add_event).with(hash_including(user: sanitized_numeric_key_user))
       client.track("custom_event_name", numeric_key_user, nil)
     end
   end
 
   describe '#identify' do 
     it "queues up an identify event" do
-      expect(client.instance_variable_get(:@event_processor)).to receive(:add_event).with(hash_including(kind: "identify", key: user[:key], user: user))
+      expect(event_processor).to receive(:add_event).with(hash_including(kind: "identify", key: user[:key], user: user))
       client.identify(user)
     end
+
     it "sanitizes the user in the event" do
-      expect(client.instance_variable_get(:@event_processor)).to receive(:add_event).with(hash_including(user: sanitized_numeric_key_user))
+      expect(event_processor).to receive(:add_event).with(hash_including(user: sanitized_numeric_key_user))
       client.identify(numeric_key_user)
     end
   end
@@ -72,24 +142,31 @@ describe LaunchDarkly::LDClient do
   end
 
   describe 'with send_events: false' do
-    let(:config) { LaunchDarkly::Config.new({offline: true, send_events: false}) }
+    let(:config) { LaunchDarkly::Config.new({offline: true, send_events: false, update_processor: update_processor}) }
     let(:client) { subject.new("secret", config) }
 
-    let(:queue) { client.instance_variable_get(:@event_processor).instance_variable_get(:@queue) }
+    it "uses a NullEventProcessor" do
+      ep = client.instance_variable_get(:@event_processor)
+      expect(ep).to be_a(LaunchDarkly::NullEventProcessor)
+    end
+  end
+
+  describe 'with send_events: true' do
+    let(:config_with_events) { LaunchDarkly::Config.new({offline: false, send_events: true, update_processor: update_processor}) }
+    let(:client_with_events) { subject.new("secret", config_with_events) }
 
-    it "does not enqueue a feature event" do
-      client.variation(feature[:key], user, "default")
-      expect(queue.empty?).to be true
+    it "does not use a NullEventProcessor" do
+      ep = client_with_events.instance_variable_get(:@event_processor)
+      expect(ep).not_to be_a(LaunchDarkly::NullEventProcessor)
     end
+  end
 
-    it "does not enqueue a custom event" do
-      client.track("custom_event_name", user, 42)
-      expect(queue.empty?).to be true
+  class NullUpdateProcessor
+    def start
     end
 
-    it "does not enqueue an identify event" do
-      client.identify(user)
-      expect(queue.empty?).to be true
+    def initialized?
+      true
     end
   end
 end

data/spec/simple_lru_cache_spec.rb

@@ -0,0 +1,24 @@
+require "spec_helper"
+
+describe LaunchDarkly::SimpleLRUCacheSet do
+  subject { LaunchDarkly::SimpleLRUCacheSet }
+
+  it "retains values up to capacity" do
+    lru = subject.new(3)
+    expect(lru.add("a")).to be false
+    expect(lru.add("b")).to be false
+    expect(lru.add("c")).to be false
+    expect(lru.add("a")).to be true
+    expect(lru.add("b")).to be true
+    expect(lru.add("c")).to be true
+  end
+
+  it "discards oldest value on overflow" do
+    lru = subject.new(2)
+    expect(lru.add("a")).to be false
+    expect(lru.add("b")).to be false
+    expect(lru.add("a")).to be true
+    expect(lru.add("c")).to be false  # b is discarded as oldest
+    expect(lru.add("b")).to be false
+  end
+end

data/spec/{event_serializer_spec.rb → user_filter_spec.rb}

@@ -1,7 +1,7 @@
 require "spec_helper"
 
-describe LaunchDarkly::EventSerializer do
-  subject { LaunchDarkly::EventSerializer }
+describe LaunchDarkly::UserFilter do
+  subject { LaunchDarkly::UserFilter }
 
   let(:base_config) { LaunchDarkly::Config.new }
   let(:config_with_all_attrs_private) { LaunchDarkly::Config.new({ all_attributes_private: true })}
@@ -45,68 +45,47 @@ describe LaunchDarkly::EventSerializer do
     { key: 'abc', anonymous: 'true', custom: { }, privateAttrs: [ 'bizzle', 'dizzle' ]}
   }
 
-
-  def make_event(user)
-    {
-      creationDate: 1000000,
-      key: 'xyz',
-      kind: 'thing',
-      user: user
-    }
-  end
-
-  def parse_results(js)
-    JSON.parse(js, symbolize_names: true)
-  end
-
   describe "serialize_events" do
     it "includes all user attributes by default" do
-      es = LaunchDarkly::EventSerializer.new(base_config)
-      event = make_event(user)
-      j = es.serialize_events([event])
-      expect(parse_results(j)).to eq [event]
+      uf = LaunchDarkly::UserFilter.new(base_config)
+      result = uf.transform_user_props(user)
+      expect(result).to eq user
     end
 
     it "hides all except key if all_attributes_private is true" do
-      es = LaunchDarkly::EventSerializer.new(config_with_all_attrs_private)
-      event = make_event(user)
-      j = es.serialize_events([event])
-      expect(parse_results(j)).to eq [make_event(user_with_all_attrs_hidden)]
+      uf = LaunchDarkly::UserFilter.new(config_with_all_attrs_private)
+      result = uf.transform_user_props(user)
+      expect(result).to eq user_with_all_attrs_hidden
     end
 
     it "hides some attributes if private_attribute_names is set" do
-      es = LaunchDarkly::EventSerializer.new(config_with_some_attrs_private)
-      event = make_event(user)
-      j = es.serialize_events([event])
-      expect(parse_results(j)).to eq [make_event(user_with_some_attrs_hidden)]
+      uf = LaunchDarkly::UserFilter.new(config_with_some_attrs_private)
+      result = uf.transform_user_props(user)
+      expect(result).to eq user_with_some_attrs_hidden
     end
 
     it "hides attributes specified in per-user privateAttrs" do
-      es = LaunchDarkly::EventSerializer.new(base_config)
-      event = make_event(user_specifying_own_private_attr)
-      j = es.serialize_events([event])
-      expect(parse_results(j)).to eq [make_event(user_with_own_specified_attr_hidden)]
+      uf = LaunchDarkly::UserFilter.new(base_config)
+      result = uf.transform_user_props(user_specifying_own_private_attr)
+      expect(result).to eq user_with_own_specified_attr_hidden
     end
 
     it "looks at both per-user privateAttrs and global config" do
-      es = LaunchDarkly::EventSerializer.new(config_with_some_attrs_private)
-      event = make_event(user_specifying_own_private_attr)
-      j = es.serialize_events([event])
-      expect(parse_results(j)).to eq [make_event(user_with_all_attrs_hidden)]
+      uf = LaunchDarkly::UserFilter.new(config_with_some_attrs_private)
+      result = uf.transform_user_props(user_specifying_own_private_attr)
+      expect(result).to eq user_with_all_attrs_hidden
     end
 
     it "strips out any unknown top-level attributes" do
-      es = LaunchDarkly::EventSerializer.new(base_config)
-      event = make_event(user_with_unknown_top_level_attrs)
-      j = es.serialize_events([event])
-      expect(parse_results(j)).to eq [make_event(user)]
+      uf = LaunchDarkly::UserFilter.new(base_config)
+      result = uf.transform_user_props(user_with_unknown_top_level_attrs)
+      expect(result).to eq user
     end
 
     it "leaves the anonymous attribute as is" do
-      es = LaunchDarkly::EventSerializer.new(config_with_all_attrs_private)
-      event = make_event(anon_user)
-      j = es.serialize_events([event])
-      expect(parse_results(j)).to eq [make_event(anon_user_with_all_attrs_hidden)]
+      uf = LaunchDarkly::UserFilter.new(config_with_all_attrs_private)
+      result = uf.transform_user_props(anon_user)
+      expect(result).to eq anon_user_with_all_attrs_hidden
     end
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: ldclient-rb
 version: !ruby/object:Gem::Version
-  version: 3.0.3
+  version: 4.0.0
 platform: ruby
 authors:
 - LaunchDarkly
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2018-03-23 00:00:00.000000000 Z
+date: 2018-05-11 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -24,20 +24,6 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '1.7'
-- !ruby/object:Gem::Dependency
-  name: rake
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '10.0'
-  type: :development
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '10.0'
 - !ruby/object:Gem::Dependency
   name: rspec
   requirement: !ruby/object:Gem::Requirement
@@ -95,19 +81,47 @@ dependencies:
       - !ruby/object:Gem::Version
         version: 2.1.2
 - !ruby/object:Gem::Dependency
-  name: moneta
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+- !ruby/object:Gem::Dependency
+  name: rspec_junit_formatter
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.3.0
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.3.0
+- !ruby/object:Gem::Dependency
+  name: timecop
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 1.0.0
+        version: 0.9.1
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 1.0.0
+        version: 0.9.1
 - !ruby/object:Gem::Dependency
   name: json
   requirement: !ruby/object:Gem::Requirement
@@ -302,6 +316,7 @@ extensions:
 - ext/mkrf_conf.rb
 extra_rdoc_files: []
 files:
+- ".circleci/config.yml"
 - ".gitignore"
 - ".hound.yml"
 - ".rspec"
@@ -314,28 +329,33 @@ files:
 - LICENSE.txt
 - README.md
 - Rakefile
-- circle.yml
 - ext/mkrf_conf.rb
 - ldclient-rb.gemspec
 - lib/ldclient-rb.rb
 - lib/ldclient-rb/cache_store.rb
 - lib/ldclient-rb/config.rb
 - lib/ldclient-rb/evaluation.rb
-- lib/ldclient-rb/event_serializer.rb
+- lib/ldclient-rb/event_summarizer.rb
 - lib/ldclient-rb/events.rb
+- lib/ldclient-rb/expiring_cache.rb
 - lib/ldclient-rb/in_memory_store.rb
 - lib/ldclient-rb/ldclient.rb
 - lib/ldclient-rb/memoized_value.rb
 - lib/ldclient-rb/newrelic.rb
+- lib/ldclient-rb/non_blocking_thread_pool.rb
 - lib/ldclient-rb/polling.rb
 - lib/ldclient-rb/redis_store.rb
 - lib/ldclient-rb/requestor.rb
+- lib/ldclient-rb/simple_lru_cache.rb
 - lib/ldclient-rb/stream.rb
+- lib/ldclient-rb/user_filter.rb
 - lib/ldclient-rb/version.rb
 - scripts/release.sh
 - spec/config_spec.rb
 - spec/evaluation_spec.rb
-- spec/event_serializer_spec.rb
+- spec/event_summarizer_spec.rb
+- spec/events_spec.rb
+- spec/expiring_cache_spec.rb
 - spec/feature_store_spec_base.rb
 - spec/fixtures/feature.json
 - spec/fixtures/feature1.json
@@ -348,9 +368,11 @@ files:
 - spec/redis_feature_store_spec.rb
 - spec/requestor_spec.rb
 - spec/segment_store_spec_base.rb
+- spec/simple_lru_cache_spec.rb
 - spec/spec_helper.rb
 - spec/store_spec.rb
 - spec/stream_spec.rb
+- spec/user_filter_spec.rb
 - spec/version_spec.rb
 homepage: https://github.com/launchdarkly/ruby-client
 licenses:
@@ -379,7 +401,9 @@ summary: LaunchDarkly SDK for Ruby
 test_files:
 - spec/config_spec.rb
 - spec/evaluation_spec.rb
-- spec/event_serializer_spec.rb
+- spec/event_summarizer_spec.rb
+- spec/events_spec.rb
+- spec/expiring_cache_spec.rb
 - spec/feature_store_spec_base.rb
 - spec/fixtures/feature.json
 - spec/fixtures/feature1.json
@@ -392,7 +416,9 @@ test_files:
 - spec/redis_feature_store_spec.rb
 - spec/requestor_spec.rb
 - spec/segment_store_spec_base.rb
+- spec/simple_lru_cache_spec.rb
 - spec/spec_helper.rb
 - spec/store_spec.rb
 - spec/stream_spec.rb
+- spec/user_filter_spec.rb
 - spec/version_spec.rb