ldclient-rb 0.8.0 → 2.0.1

data/lib/ldclient-rb/polling.rb

@@ -0,0 +1,56 @@
+require "concurrent/atomics"
+require "thread"
+
+module LaunchDarkly
+  class PollingProcessor
+    
+    def initialize(config, requestor)
+      @config = config
+      @requestor = requestor
+      @initialized = Concurrent::AtomicBoolean.new(false)
+      @started = Concurrent::AtomicBoolean.new(false)
+    end
+
+    def initialized?
+      @initialized.value
+    end
+
+    def start
+      return unless @started.make_true
+      @config.logger.info("[LDClient] Initializing polling connection")
+      create_worker
+    end
+
+    def poll
+      flags = @requestor.request_all_flags
+      if flags
+        @config.feature_store.init(flags)
+        if @initialized.make_true
+          @config.logger.info("[LDClient] Polling connection initialized")
+        end
+      end
+    end
+
+    def create_worker
+      Thread.new do
+        @config.logger.debug("[LDClient] Starting polling worker")
+        loop do
+          begin
+            started_at = Time.now
+            poll
+            delta = @config.poll_interval - (Time.now - started_at)
+            if delta > 0
+              sleep(delta)
+            end
+          rescue StandardError => exn
+            @config.logger.error("[LDClient] Exception while polling: #{exn.inspect}")
+           # TODO: log_exception(__method__.to_s, exn)
+          end
+        end
+      end
+    end
+
+
+    private :poll, :create_worker
+  end
+end

data/lib/ldclient-rb/requestor.rb

@@ -0,0 +1,56 @@
+require "json"
+require "net/http/persistent"
+require "faraday/http_cache"
+
+module LaunchDarkly
+
+  class Requestor
+    def initialize(sdk_key, config)
+      @sdk_key = sdk_key
+      @config = config
+      @client = Faraday.new do |builder|
+        builder.use :http_cache, store: @config.cache_store
+
+        builder.adapter :net_http_persistent
+      end
+    end
+
+    def request_all_flags()
+      make_request("/sdk/latest-flags")
+    end
+
+    def request_flag(key)
+      make_request("/sdk/latest-flags/" + key)
+    end
+
+    def make_request(path)
+      res = @client.get (@config.base_uri + path) do |req|
+        req.headers["Authorization"] = @sdk_key
+        req.headers["User-Agent"] = "RubyClient/" + LaunchDarkly::VERSION
+        req.options.timeout = @config.read_timeout
+        req.options.open_timeout = @config.connect_timeout
+      end
+
+      if res.status == 401
+        @config.logger.error("[LDClient] Invalid SDK key")
+        return nil
+      end
+
+      if res.status == 404
+        @config.logger.error("[LDClient] Resource not found")
+        return nil
+      end
+
+      if res.status / 100 != 2
+        @config.logger.error("[LDClient] Unexpected status code #{res.status}")
+        return nil
+      end
+
+      JSON.parse(res.body, symbolize_names: true)
+    end
+
+    private :make_request
+
+  end
+
+end

data/lib/ldclient-rb/stream.rb

@@ -1,173 +1,73 @@
 require "concurrent/atomics"
 require "json"
-require "ld-em-eventsource"
+require "celluloid/eventsource"
 
 module LaunchDarkly
-  PUT = "put"
-  PATCH = "patch"
-  DELETE = "delete"
-
-  class InMemoryFeatureStore
-    def initialize
-      @features = Hash.new
-      @lock = Concurrent::ReadWriteLock.new
-      @initialized = Concurrent::AtomicBoolean.new(false)
-    end
-
-    def get(key)
-      @lock.with_read_lock do
-        f = @features[key.to_sym]
-        (f.nil? || f[:deleted]) ? nil : f
-      end
-    end
-
-    def all
-      @lock.with_read_lock do
-        @features.select { |_k, f| not f[:deleted] }
-      end
-    end
-
-    def delete(key, version)
-      @lock.with_write_lock do
-        old = @features[key.to_sym]
-
-        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 }
-        end
-      end
-    end
-
-    def init(fs)
-      @lock.with_write_lock do
-        @features.replace(fs)
-        @initialized.make_true
-      end
-    end
-
-    def upsert(key, feature)
-      @lock.with_write_lock do
-        old = @features[key.to_sym]
-
-        if old.nil? || old[:version] < feature[:version]
-          @features[key.to_sym] = feature
-        end
-      end
-    end
-
-    def initialized?
-      @initialized.value
-    end
-  end
+  PUT = :put
+  PATCH = :patch
+  DELETE = :delete
+  INDIRECT_PUT = :'indirect/put'
+  INDIRECT_PATCH = :'indirect/patch'
 
   class StreamProcessor
-    def initialize(api_key, config)
-      @api_key = api_key
+    def initialize(sdk_key, config, requestor)
+      @sdk_key = sdk_key
       @config = config
-      @store = config.feature_store ? config.feature_store : InMemoryFeatureStore.new
-      @disconnected = Concurrent::AtomicReference.new(nil)
+      @store = config.feature_store
+      @requestor = requestor
+      @initialized = Concurrent::AtomicBoolean.new(false)
       @started = Concurrent::AtomicBoolean.new(false)
     end
 
     def initialized?
-      @store.initialized?
-    end
-
-    def started?
-      @started.value
-    end
-
-    def get_all_features
-      if not initialized?
-        throw :uninitialized
-      end
-      @store.all
-    end
-
-    def get_feature(key)
-      if not initialized?
-        throw :uninitialized
-      end
-      @store.get(key)
-    end
-
-    def start_reactor
-      if defined?(Thin)
-        @config.logger.debug("Running in a Thin environment-- not starting EventMachine")
-      elsif EM.reactor_running?
-        @config.logger.debug("EventMachine already running")
-      else
-        @config.logger.debug("Starting EventMachine")
-        Thread.new { EM.run {} }
-        Thread.pass until EM.reactor_running?
-      end
-      EM.reactor_running?
+      @initialized.value
     end
 
     def start
-      # Try to start the reactor. If it's not started, we shouldn't start
-      # the stream processor
-      return if not start_reactor
-
-      # If someone else booted the stream processor connection, just return
       return unless @started.make_true
 
-      # If we're the first and only thread to set started, boot
-      # the stream processor connection
-      EM.defer do
-        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] Stream connection: #{error}")
-        set_disconnected
+      @config.logger.info("[LDClient] Initializing stream connection")
+      
+      headers = 
+      {
+        'Authorization' => @sdk_key,
+        'User-Agent' => 'RubyClient/' + LaunchDarkly::VERSION
+      }
+      opts = {:headers => headers, :with_credentials => true}
+      @es = Celluloid::EventSource.new(@config.stream_uri + "/flags", 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) }
+        conn.on(INDIRECT_PUT) { |message| process_message(message, INDIRECT_PUT) }
+        conn.on(INDIRECT_PATCH) { |message| process_message(message, INDIRECT_PATCH) }
+        conn.on_error do |message|
+          @config.logger.error("[LDClient] Error connecting to stream. Status code: #{message[:status_code]}")
+        end
       end
-      source.inactivity_timeout = 0
-      source.start
-      source
     end
 
     def process_message(message, method)
-      message = JSON.parse(message, symbolize_names: true)
+      message = JSON.parse(message.data, symbolize_names: true)
+      @config.logger.debug("[LDClient] Stream received #{method} message")
       if method == PUT
         @store.init(message)
+        @initialized.make_true
+        @config.logger.info("[LDClient] Stream initialized")
       elsif method == PATCH
         @store.upsert(message[:path][1..-1], message[:data])
       elsif method == DELETE
         @store.delete(message[:path][1..-1], message[:version])
+      elsif method == INDIRECT_PUT
+        @store.init(@requestor.request_all_flags)
+        @initialized.make_true
+        @config.logger.info("[LDClient] Stream initialized (via indirect message)")
+      elsif method == INDIRECT_PATCH
+        @store.upsert(@requestor.request_flag(message[:data]))        
       else
         @config.logger.error("[LDClient] Unknown message received: #{method}")
       end
-      set_connected
-    end
-
-    def set_disconnected
-      @disconnected.set(Time.now)
-    end
-
-    def set_connected
-      @disconnected.set(nil)
-    end
-
-    def should_fallback_update
-      disc = @disconnected.get
-      !disc.nil? && disc < (Time.now - 120)
     end
 
-    # TODO mark private methods
-    private :boot_event_manager, :process_message, :set_connected, :set_disconnected, :start_reactor
+    private :process_message
   end
 end

data/lib/ldclient-rb/version.rb

@@ -1,3 +1,3 @@
 module LaunchDarkly
-  VERSION = "0.8.0"
+  VERSION = "2.0.1"
 end

data/spec/config_spec.rb

@@ -32,14 +32,14 @@ describe LaunchDarkly::Config do
       expect(subject.new.stream_uri).to eq subject.default_stream_uri
     end
   end
-  describe ".default_store" do
+  describe ".default_cache_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
+      expect(subject.default_cache_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
+      expect(subject.default_cache_store).to be_an_instance_of LaunchDarkly::ThreadSafeMemoryStore
     end
   end
   describe ".default_logger" do

data/spec/fixtures/feature.json

@@ -1,67 +1,36 @@
 {
-   "name":"New recommendations engine",
-   "key":"engine.enable",
-   "kind":"flag",
-   "salt":"ZW5naW5lLmVuYWJsZQ==",
+   "key":"test-feature-flag",
+   "version":11,
    "on":true,
-   "variations":[
+   "prerequisites":[
+
+   ],
+   "salt":"718ea30a918a4eba8734b57ab1a93227",
+   "sel":"fe1244e5378c4f99976c9634e33667c6",
+   "targets":[
       {
-         "value":true,
-         "weight":31,
-         "targets":[
-            {
-               "attribute":"groups",
-               "op":"in",
-               "values":[
-                  "Microsoft"
-               ]
-            }
+         "values":[
+            "alice"
          ],
-         "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"
-            ]
-         }
+         "variation":0
       },
       {
-         "value":false,
-         "weight":69,
-         "targets":[
-            {
-               "attribute":"key",
-               "op":"in",
-               "values":[
-                  "Alida.Caples@example.com"
-               ]
-            },
-            {
-               "attribute":"groups",
-               "op":"in",
-               "values":[
-
-               ]
-            }
+         "values":[
+            "bob"
          ],
-         "userTarget":{
-            "attribute":"key",
-            "op":"in",
-            "values":[
-               "Alida.Caples@example.com"
-            ]
-         }
+         "variation":1
       }
    ],
-   "ttl":0,
-   "commitDate":"2015-05-10T06:06:45.381Z",
-   "creationDate":"2014-09-02T20:39:18.61Z"
-}
+   "rules":[
+
+   ],
+   "fallthrough":{
+      "variation":0
+   },
+   "offVariation":1,
+   "variations":[
+      true,
+      false
+   ],
+   "deleted":false
+}

data/spec/ldclient_spec.rb

@@ -1,10 +1,11 @@
 require "spec_helper"
 
+
 describe LaunchDarkly::LDClient do
   subject { LaunchDarkly::LDClient }
+  let(:config) { LaunchDarkly::Config.new({:offline => true}) }  
   let(:client) do
-    expect_any_instance_of(LaunchDarkly::LDClient).to receive :create_worker
-    subject.new("api_key")
+    subject.new("secret", config)
   end
   let(:feature) do
     data = File.read(File.join("spec", "fixtures", "feature.json"))
@@ -23,246 +24,39 @@ describe LaunchDarkly::LDClient do
     JSON.parse(data, symbolize_names: true)
   end
 
-  context 'user flag settings' do
-    describe '#update_user_flag_setting' do
-      it 'requires user' do
-        expect(client.instance_variable_get(:@config).logger).to receive(:error)
-        client.update_user_flag_setting(nil, feature[:key], true)
-      end
-
-      it 'puts the new setting' do
-        result = double('result', success?: true, status: 204)
-        expect(client.instance_variable_get(:@client)).to receive(:put).and_return(result)
-        client.update_user_flag_setting(user[:key], feature[:key], true)
-      end
-    end
-  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).with(LaunchDarkly::Config.default_events_uri + "/bulk").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 "will specify the default value in the feature request event" do
-      expect(client).to receive(:add_event).with(hash_including(default: "default"))
-      result = client.toggle?(feature[:key], user, "default")
-    end
-    it "requires user" do
-      expect(client.instance_variable_get(:@config).logger).to receive(:error)
-      result = client.toggle?(feature[:key], nil, "default")
+  describe '#variation' do
+    it "will return the default value if the client is offline" do
+      result = client.variation(feature[:key], user, "default")
       expect(result).to eq "default"
     end
-    it "sanitizes the user in the event" do
-      expect(client).to receive(:add_event).with(hash_including(user: sanitized_numeric_key_user))
-      client.toggle?(feature[:key], numeric_key_user, "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 '#identify' do 
-    it "queues up an identify event" do
-      expect(client).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).to receive(:add_event).with(hash_including(user: sanitized_numeric_key_user))
-      client.identify(numeric_key_user)
+  describe '#secure_mode_hash' do
+    it "will return the expected value for a known message and secret" do
+      result = client.secure_mode_hash({:key => :Message})
+      expect(result).to eq "aa747c502a898200f9e4fa21bac68136f886a0e27aec70ba06daf2e2a5cb5597"
     end
   end
 
   describe '#track' do 
     it "queues up an custom event" do
-      expect(client).to receive(:add_event).with(hash_including(kind: "custom", key: "custom_event_name", user: user, data: 42))
+      expect(client.instance_variable_get(:@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).to receive(:add_event).with(hash_including(user: sanitized_numeric_key_user))
+      expect(client.instance_variable_get(:@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 '#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 '#all_flags' do
-    it "will parse and return the features list" do
-      result = double("Faraday::Response", status: 200, body: '{"asdf":"qwer"}')
-      expect(client).to receive(:make_request).with("/api/eval/features").and_return(result)
-      data = client.send(:all_flags)
-      expect(data).to eq(asdf: "qwer")
-    end
-    it "will log errors" do
-      result = double("Faraday::Response", status: 418)
-      expect(client).to receive(:make_request).with("/api/eval/features").and_return(result)
-      expect(client.instance_variable_get(:@config).logger).to receive(:error)
-      client.send(:all_flags)
-    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)
+  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))
+      client.identify(user)
     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
+    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))
+      client.identify(numeric_key_user)
     end
   end
 
@@ -276,4 +70,4 @@ describe LaunchDarkly::LDClient do
       end
     end
   end
-end
+end