ldclient-rb 0.4.0 → 0.5.0

data/lib/ldclient-rb/newrelic.rb

@@ -1,19 +1,16 @@
 module LaunchDarkly
-
   class LDNewRelic
     begin
-      require 'newrelic_rpm'
+      require "newrelic_rpm"
       NR_ENABLED = defined?(::NewRelic::Agent.add_custom_parameters)
-    rescue Exception
+    rescue ScriptError, StandardError
       NR_ENABLED = false
     end
 
     def self.annotate_transaction(key, value)
       if NR_ENABLED
-        ::NewRelic::Agent.add_custom_parameters({key.to_s => value.to_s})
+        ::NewRelic::Agent.add_custom_parameters(key.to_s => value.to_s)
       end
     end
   end
-
-
-end
+end

data/lib/ldclient-rb/store.rb

@@ -1,37 +1,36 @@
-require 'thread_safe'
+require "thread_safe"
 
 module LaunchDarkly
-
   # A thread-safe in-memory store suitable for use
   # with the Faraday caching HTTP client. Uses the
-  # Threadsafe gem as the underlying cache. 
-  # 
+  # Threadsafe gem as the underlying cache.
+  #
   # @see https://github.com/plataformatec/faraday-http-cache
   # @see https://github.com/ruby-concurrency/thread_safe
-  # 
+  #
   class ThreadSafeMemoryStore
-    # 
+    #
     # Default constructor
-    # 
+    #
     # @return [ThreadSafeMemoryStore] a new store
     def initialize
       @cache = ThreadSafe::Cache.new
     end
 
-    # 
+    #
     # Read a value from the cache
     # @param key [Object] the cache key
-    # 
+    #
     # @return [Object] the cache value
     def read(key)
       @cache[key]
     end
 
-    # 
+    #
     # Store a value in the cache
     # @param key [Object] the cache key
     # @param value [Object] the value to associate with the key
-    # 
+    #
     # @return [Object] the value
     def write(key, value)
       @cache[key] = value

data/lib/ldclient-rb/stream.rb

@@ -1,67 +1,66 @@
-require 'concurrent/atomics'
-require 'json'
-require 'ld-em-eventsource'
+require "concurrent/atomics"
+require "json"
+require "ld-em-eventsource"
 
 module LaunchDarkly
-
   PUT = "put"
   PATCH = "patch"
   DELETE = "delete"
 
   class InMemoryFeatureStore
-    def initialize()
+    def initialize
       @features = Hash.new
       @lock = Concurrent::ReadWriteLock.new
       @initialized = Concurrent::AtomicBoolean.new(false)
     end
 
     def get(key)
-      @lock.with_read_lock {
+      @lock.with_read_lock do
         f = @features[key.to_sym]
         (f.nil? || f[:deleted]) ? nil : f
-      }
+      end
     end
 
-    def all()
-      @lock.with_read_lock {
-        @features.select {|k,f| not f[:deleted]}  
-      }
+    def all
+      @lock.with_read_lock do
+        @features.select { |_k, f| not f[:deleted] }
+      end
     end
 
     def delete(key, version)
-      @lock.with_write_lock {
+      @lock.with_write_lock do
         old = @features[key.to_sym]
 
-        if old != nil and old[:version] < version
+        if !old.nil? && old[:version] < version
           old[:deleted] = true
           old[:version] = version
           @features[key.to_sym] = old
         elsif old.nil?
-          @features[key.to_sym] = {:deleted => true, :version => version}
+          @features[key.to_sym] = { deleted: true, version: version }
         end
-      }
+      end
     end
 
     def init(fs)
-      @lock.with_write_lock {
+      @lock.with_write_lock do
         @features.replace(fs)
         @initialized.make_true
-      }
+      end
     end
 
     def upsert(key, feature)
-      @lock.with_write_lock {
+      @lock.with_write_lock do
         old = @features[key.to_sym]
 
-        if old.nil? or old[:version] < feature[:version]
+        if old.nil? || old[:version] < feature[:version]
           @features[key.to_sym] = feature
         end
-      }
+      end
     end
 
-    def initialized?()
+    def initialized?
       @initialized.value
-    end    
+    end
   end
 
   class StreamProcessor
@@ -73,11 +72,11 @@ module LaunchDarkly
       @started = Concurrent::AtomicBoolean.new(false)
     end
 
-    def initialized?()
+    def initialized?
       @store.initialized?
     end
 
-    def started?()
+    def started?
       @started.value
     end
 
@@ -88,9 +87,9 @@ module LaunchDarkly
       @store.get(key)
     end
 
-    def start_reactor()
+    def start_reactor
       if defined?(Thin)
-        @config.logger.debug("Running in a Thin environment-- not starting EventMachine")        
+        @config.logger.debug("Running in a Thin environment-- not starting EventMachine")
       elsif EM.reactor_running?
         @config.logger.debug("EventMachine already running")
       else
@@ -101,66 +100,67 @@ module LaunchDarkly
       EM.reactor_running?
     end
 
-    def start()
+    def start
       # Try to start the reactor. If it's not started, we shouldn't start
       # the stream processor
-      if not start_reactor
-        return
-      end
+      return if not start_reactor
 
       # If someone else booted the stream processor connection, just return
-      if not @started.make_true
-        return
-      end
+      return unless @started.make_true
 
       # If we're the first and only thread to set started, boot
       # the stream processor connection
       EM.defer do
-        source = EM::EventSource.new(@config.stream_uri + "/features",
-                                    {},
-                                    {'Accept' => 'text/event-stream',
-                                     'Authorization' => 'api_key ' + @api_key,
-                                     'User-Agent' => 'RubyClient/' + LaunchDarkly::VERSION})
-        source.on PUT do |message|
-          features = JSON.parse(message, :symbolize_names => true)
-          @store.init(features)
-          set_connected            
-        end
-        source.on PATCH do |message|
-          json = JSON.parse(message, :symbolize_names => true)
-          @store.upsert(json[:path][1..-1], json[:data])
-          set_connected
-        end
-        source.on DELETE do |message|
-          json = JSON.parse(message, :symbolize_names => true)
-          @store.delete(json[:path][1..-1], json[:version])
-          set_connected
-        end
-        source.error do |error|
-          @config.logger.error("[LDClient] Error subscribing to stream API: #{error}")
-          set_disconnected
-        end
-        source.inactivity_timeout = 0
-        source.start
+        boot_event_manager
+      end
+    end
+
+    def boot_event_manager
+      source = EM::EventSource.new(@config.stream_uri + "/features",
+                                   {},
+                                   "Accept" => "text/event-stream",
+                                   "Authorization" => "api_key " + @api_key,
+                                   "User-Agent" => "RubyClient/" + LaunchDarkly::VERSION)
+      source.on(PUT) { |message| process_message(message, PUT) }
+      source.on(PATCH) { |message| process_message(message, PATCH) }
+      source.on(DELETE) { |message| process_message(message, DELETE) }
+      source.error do |error|
+        @config.logger.info("[LDClient] Error subscribing to stream API: #{error}")
+        set_disconnected
       end
+      source.inactivity_timeout = 0
+      source.start
+      source
     end
 
-    def set_disconnected()
+    def process_message(message, method)
+      message = JSON.parse(message, symbolize_names: true)
+      if method == PUT
+        @store.init(message)
+      elsif method == PATCH
+        @store.upsert(message[:path][1..-1], message[:data])
+      elsif method == DELETE
+        @store.delete(message[:path][1..-1], message[:version])
+      else
+        @config.logger.error("[LDClient] Unknown message received: #{method}")
+      end
+      set_connected
+    end
+
+    def set_disconnected
       @disconnected.set(Time.now)
     end
 
-    def set_connected()
+    def set_connected
       @disconnected.set(nil)
     end
 
-    def should_fallback_update()
+    def should_fallback_update
       disc = @disconnected.get
-      disc != nil and disc < (Time.now - 120)
+      !disc.nil? && disc < (Time.now - 120)
     end
 
     # TODO mark private methods
-    private :set_connected, :set_disconnected, :start_reactor
-
+    private :boot_event_manager, :process_message, :set_connected, :set_disconnected, :start_reactor
   end
-
-end
+end

data/lib/ldclient-rb/version.rb

@@ -1,3 +1,3 @@
 module LaunchDarkly
-  VERSION = "0.4.0"
+  VERSION = "0.5.0"
 end

data/spec/config_spec.rb

@@ -0,0 +1,45 @@
+require "spec_helper"
+
+describe LaunchDarkly::Config do
+  subject { LaunchDarkly::Config }
+  describe ".initialize" do
+    it "can be initialized with default settings" do
+      expect(subject).to receive(:default_capacity).and_return 1234
+      expect(subject.new.capacity).to eq 1234
+    end
+    it "accepts custom arguments" do
+      expect(subject).to_not receive(:default_capacity)
+      expect(subject.new(capacity: 50).capacity).to eq 50
+    end
+    it "will chomp base_url and stream_uri" do
+      uri = "https://test.launchdarkly.com"
+      config = subject.new(base_uri: uri + "/")
+      expect(config.base_uri).to eq uri
+    end
+  end
+  describe "@base_uri" do
+    it "can be read" do
+      expect(subject.new.base_uri).to eq subject.default_base_uri
+    end
+  end
+  describe ".default_store" do
+    it "uses Rails cache if it is available" do
+      rails = instance_double("Rails", cache: :cache)
+      stub_const("Rails", rails)
+      expect(subject.default_store).to eq :cache
+    end
+    it "uses memory store if Rails is not available" do
+      expect(subject.default_store).to be_an_instance_of LaunchDarkly::ThreadSafeMemoryStore
+    end
+  end
+  describe ".default_logger" do
+    it "uses Rails logger if it is available" do
+      rails = instance_double("Rails", logger: :logger)
+      stub_const("Rails", rails)
+      expect(subject.default_logger).to eq :logger
+    end
+    it "Uses logger if Rails is not available" do
+      expect(subject.default_logger).to be_an_instance_of Logger
+    end
+  end
+end

data/spec/fixtures/feature.json

@@ -0,0 +1,67 @@
+{
+   "name":"New recommendations engine",
+   "key":"engine.enable",
+   "kind":"flag",
+   "salt":"ZW5naW5lLmVuYWJsZQ==",
+   "on":true,
+   "variations":[
+      {
+         "value":true,
+         "weight":31,
+         "targets":[
+            {
+               "attribute":"groups",
+               "op":"in",
+               "values":[
+                  "Microsoft"
+               ]
+            }
+         ],
+         "userTarget":{
+            "attribute":"key",
+            "op":"in",
+            "values":[
+               "foo@bar.com",
+               "Abbey.Orkwis@example.com",
+               "Abbie.Stolte@example.com",
+               "44d2781c-5985-4d89-b07a-0dffbd24126f",
+               "0ffe4f0c-7aa9-4621-a87c-abe1c051abd8",
+               "f52d99be-6a40-4cdd-a7b4-0548834fcbe5",
+               "Vernetta.Belden@example.com",
+               "c9d591bd-ea1f-465f-86d2-239ea41d0f0f",
+               "870745092"
+            ]
+         }
+      },
+      {
+         "value":false,
+         "weight":69,
+         "targets":[
+            {
+               "attribute":"key",
+               "op":"in",
+               "values":[
+                  "Alida.Caples@example.com"
+               ]
+            },
+            {
+               "attribute":"groups",
+               "op":"in",
+               "values":[
+
+               ]
+            }
+         ],
+         "userTarget":{
+            "attribute":"key",
+            "op":"in",
+            "values":[
+               "Alida.Caples@example.com"
+            ]
+         }
+      }
+   ],
+   "ttl":0,
+   "commitDate":"2015-05-10T06:06:45.381Z",
+   "creationDate":"2014-09-02T20:39:18.61Z"
+}

data/spec/fixtures/user.json

@@ -0,0 +1,9 @@
+{
+    "key":"user@test.com",
+    "custom":{
+        "groups":[
+            "microsoft",
+            "google"
+        ]
+    }
+}

data/spec/ldclient_spec.rb

@@ -0,0 +1,226 @@
+require "spec_helper"
+
+describe LaunchDarkly::LDClient do
+  subject { LaunchDarkly::LDClient }
+  let(:client) do
+    expect_any_instance_of(LaunchDarkly::LDClient).to receive :create_worker
+    subject.new("api_key")
+  end
+  let(:feature) do
+    data = File.read(File.join("spec", "fixtures", "feature.json"))
+    JSON.parse(data, symbolize_names: true)
+  end
+  let(:user) do
+    data = File.read(File.join("spec", "fixtures", "user.json"))
+    JSON.parse(data, symbolize_names: true)
+  end
+
+  describe '#flush' do
+    it "will flush and post all events" do
+      client.instance_variable_get(:@queue).push "asdf"
+      client.instance_variable_get(:@queue).push "asdf"
+      expect(client).to receive(:post_flushed_events)
+      client.flush
+      expect(client.instance_variable_get(:@queue).length).to eq 0
+    end
+    it "will not do anything if there are no events" do
+      expect(client).to_not receive(:post_flushed_events)
+      expect(client.instance_variable_get(:@config).logger).to_not receive :error
+      client.flush
+    end
+  end
+
+  describe '#post_flushed_events' do
+    let(:events) { ["event"] }
+    it "will flush and post all events" do
+      result = double("result", status: 200)
+      expect(client.instance_variable_get(:@client)).to receive(:post).and_return result
+      expect(client.instance_variable_get(:@config).logger).to_not receive :error
+      client.send(:post_flushed_events, events)
+      expect(client.instance_variable_get(:@queue).length).to eq 0
+    end
+    it "will allow any 2XX response" do
+      result = double("result", status: 202)
+      expect(client.instance_variable_get(:@client)).to receive(:post).and_return result
+      expect(client.instance_variable_get(:@config).logger).to_not receive :error
+      client.send(:post_flushed_events, events)
+    end
+    it "will work with unexpected post results" do
+      result = double("result", status: 418)
+      expect(client.instance_variable_get(:@client)).to receive(:post).and_return result
+      expect(client.instance_variable_get(:@config).logger).to receive :error
+      client.send(:post_flushed_events, events)
+      expect(client.instance_variable_get(:@queue).length).to eq 0
+    end
+  end
+
+  describe '#toggle?' do
+    it "will not fail" do
+      expect(client.instance_variable_get(:@config)).to receive(:stream?).and_raise RuntimeError
+      expect(client.instance_variable_get(:@config).logger).to receive(:error)
+      result = client.toggle?(feature[:key], user, "default")
+      expect(result).to eq "default"
+    end
+    it "requires user" do
+      expect(client.instance_variable_get(:@config).logger).to receive(:error)
+      result = client.toggle?(feature[:key], nil, "default")
+      expect(result).to eq "default"
+    end
+    it "returns value from streamed flag if available" do
+      expect(client.instance_variable_get(:@config)).to receive(:stream?).and_return(true).twice
+      expect(client.instance_variable_get(:@stream_processor)).to receive(:started?).and_return true
+      expect(client.instance_variable_get(:@stream_processor)).to receive(:initialized?).and_return true
+      expect(client).to receive(:add_event)
+      expect(client).to receive(:get_streamed_flag).and_return feature
+      result = client.toggle?(feature[:key], user, "default")
+      expect(result).to eq false
+    end
+    it "returns value from normal request if streamed flag is not available" do
+      expect(client.instance_variable_get(:@config)).to receive(:stream?).and_return(false).twice
+      expect(client).to receive(:add_event)
+      expect(client).to receive(:get_flag_int).and_return feature
+      result = client.toggle?(feature[:key], user, "default")
+      expect(result).to eq false
+    end
+  end
+
+  describe '#get_streamed_flag' do
+    it "will not check the polled flag normally" do
+      expect(client).to receive(:get_flag_stream).and_return true
+      expect(client).to_not receive(:get_flag_int)
+      expect(client.send(:get_streamed_flag, "key")).to eq true
+    end
+    context "debug stream" do
+      it "will log an error if the streamed and polled flag do not match" do
+        expect(client.instance_variable_get(:@config)).to receive(:debug_stream?).and_return true
+        expect(client).to receive(:get_flag_stream).and_return true
+        expect(client).to receive(:get_flag_int).and_return false
+        expect(client.instance_variable_get(:@config).logger).to receive(:error)
+        expect(client.send(:get_streamed_flag, "key")).to eq true
+      end
+    end
+  end
+
+  describe '#get_features' do
+    it "will parse and return the features list" do
+      result = double("Faraday::Response", status: 200, body: '{"items": ["asdf"]}')
+      expect(client).to receive(:make_request).with("/api/features").and_return(result)
+      data = client.send(:get_features)
+      expect(data).to eq ["asdf"]
+    end
+    it "will log errors" do
+      result = double("Faraday::Response", status: 418)
+      expect(client).to receive(:make_request).with("/api/features").and_return(result)
+      expect(client.instance_variable_get(:@config).logger).to receive(:error)
+      client.send(:get_features)
+    end
+  end
+
+  describe '#get_flag_int' do
+    it "will return the parsed flag" do
+      result = double("Faraday::Response", status: 200, body: '{"asdf":"qwer"}')
+      expect(client).to receive(:make_request).with("/api/eval/features/key").and_return(result)
+      data = client.send(:get_flag_int, "key")
+      expect(data).to eq(asdf: "qwer")
+    end
+    it "will accept 401 statuses" do
+      result = double("Faraday::Response", status: 401)
+      expect(client).to receive(:make_request).with("/api/eval/features/key").and_return(result)
+      expect(client.instance_variable_get(:@config).logger).to receive(:error)
+      data = client.send(:get_flag_int, "key")
+      expect(data).to be_nil
+    end
+    it "will accept 404 statuses" do
+      result = double("Faraday::Response", status: 404)
+      expect(client).to receive(:make_request).with("/api/eval/features/key").and_return(result)
+      expect(client.instance_variable_get(:@config).logger).to receive(:error)
+      data = client.send(:get_flag_int, "key")
+      expect(data).to be_nil
+    end
+    it "will accept non-standard statuses" do
+      result = double("Faraday::Response", status: 418)
+      expect(client).to receive(:make_request).with("/api/eval/features/key").and_return(result)
+      expect(client.instance_variable_get(:@config).logger).to receive(:error)
+      data = client.send(:get_flag_int, "key")
+      expect(data).to be_nil
+    end
+  end
+
+  describe '#make_request' do
+    it "will make a proper request" do
+      expect(client.instance_variable_get :@client).to receive(:get)
+      client.send(:make_request, "/asdf")
+    end
+  end
+
+  describe '#param_for_user' do
+    it "will return a consistent hash of a user key, feature key, and feature salt" do
+      param = client.send(:param_for_user, feature, user)
+      expect(param).to be_between(0.0, 1.0).inclusive
+    end
+  end
+
+  describe '#evaluate' do
+    it "will return nil if there is no feature" do
+      expect(client.send(:evaluate, nil, user)).to eq nil
+    end
+    it "will return nil unless the feature is on" do
+      feature[:on] = false
+      expect(client.send(:evaluate, feature, user)).to eq nil
+    end
+    it "will return value if it matches the user" do
+      user = { key: "Alida.Caples@example.com" }
+      expect(client.send(:evaluate, feature, user)).to eq false
+      user = { key: "foo@bar.com" }
+      expect(client.send(:evaluate, feature, user)).to eq true
+    end
+    it "will return value if the target matches" do
+      user = { key: "asdf@asdf.com", custom: { groups: "Microsoft" } }
+      expect(client.send(:evaluate, feature, user)).to eq true
+    end
+    it "will return value if the weight matches" do
+      expect(client).to receive(:param_for_user).and_return 0.1
+      expect(client.send(:evaluate, feature, user)).to eq true
+      expect(client).to receive(:param_for_user).and_return 0.9
+      expect(client.send(:evaluate, feature, user)).to eq false
+    end
+  end
+
+  describe '#log_timings' do
+    let(:block) { lambda { "result" } }
+    let(:label) { "label" }
+    it "will not measure if not configured to do so" do
+      expect(Benchmark).to_not receive(:measure)
+      client.send(:log_timings, label, &block)
+    end
+    context "logging enabled" do
+      before do
+        expect(client.instance_variable_get(:@config)).to receive(:log_timings?).and_return true
+        expect(client.instance_variable_get(:@config).logger).to receive(:debug?).and_return true
+      end
+      it "will benchmark timings and return result" do
+        expect(Benchmark).to receive(:measure).and_call_original
+        expect(client.instance_variable_get(:@config).logger).to receive(:debug)
+        result = client.send(:log_timings, label, &block)
+        expect(result).to eq "result"
+      end
+      it "will raise exceptions if the block has them" do
+        block = lambda { raise RuntimeError }
+        expect(Benchmark).to receive(:measure).and_call_original
+        expect(client.instance_variable_get(:@config).logger).to receive(:debug)
+        expect { client.send(:log_timings, label, &block) }.to raise_error RuntimeError
+      end
+    end
+  end
+
+  describe '#log_exception' do
+    it "log error data" do
+      expect(client.instance_variable_get(:@config).logger).to receive(:error)
+      begin
+        raise StandardError.new 'asdf'
+      rescue StandardError => exn
+        client.send(:log_exception, 'caller', exn)
+      end
+    end
+  end
+end