ldclient-rb 0.8.0 → 2.0.1

data/lib/ldclient-rb/events.rb

@@ -0,0 +1,75 @@
+require "thread"
+require "faraday"
+
+module LaunchDarkly
+
+  class EventProcessor
+    def initialize(sdk_key, config)
+      @queue = Queue.new
+      @sdk_key = sdk_key
+      @config = config
+      @client = Faraday.new
+      @worker = create_worker
+    end
+
+    def create_worker
+      Thread.new do
+        loop do
+          begin
+            flush
+            sleep(@config.flush_interval)
+          rescue StandardError => exn
+            log_exception(__method__.to_s, exn)
+          end
+        end
+      end
+    end
+
+    def post_flushed_events(events)
+      res = @client.post (@config.events_uri + "/bulk") do |req|
+        req.headers["Authorization"] = @sdk_key
+        req.headers["User-Agent"] = "RubyClient/" + LaunchDarkly::VERSION
+        req.headers["Content-Type"] = "application/json"
+        req.body = events.to_json
+        req.options.timeout = @config.read_timeout
+        req.options.open_timeout = @config.connect_timeout
+      end
+      if res.status / 100 != 2
+        @config.logger.error("[LDClient] Unexpected status code while processing events: #{res.status}")
+      end
+    end
+
+    def flush
+      events = []
+      begin
+        loop do
+          events << @queue.pop(true)
+        end
+      rescue ThreadError
+      end
+
+      if !events.empty?
+        post_flushed_events(events)
+      end
+    end
+
+    def add_event(event)
+      return if @offline
+
+      if @queue.length < @config.capacity
+        event[:creationDate] = (Time.now.to_f * 1000).to_i
+        @config.logger.debug("[LDClient] Enqueueing event: #{event.to_json}")
+        @queue.push(event)
+
+        if !@worker.alive?
+          @worker = create_worker
+        end
+      else
+        @config.logger.warn("[LDClient] Exceeded event queue capacity. Increase capacity to avoid dropping events.")
+      end
+    end  
+
+    private :create_worker, :post_flushed_events
+  
+  end
+end

data/lib/ldclient-rb/feature_store.rb

@@ -0,0 +1,60 @@
+require "concurrent/atomics"
+
+module LaunchDarkly
+  
+  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
+end

data/lib/ldclient-rb/ldclient.rb

@@ -1,100 +1,77 @@
-require "faraday/http_cache"
-require "json"
 require "digest/sha1"
-require "thread"
 require "logger"
-require "net/http/persistent"
 require "benchmark"
-require "hashdiff"
+require "waitutil"
+require "json"
+require "openssl"
 
 module LaunchDarkly
-  BUILTINS = [:key, :ip, :country, :email, :firstName, :lastName, :avatar, :name, :anonymous]
-
   #
-  # A client for the LaunchDarkly API. Client instances are thread-safe. Users
+  # A client for LaunchDarkly. Client instances are thread-safe. Users
   # should create a single client instance for the lifetime of the application.
   #
   #
   class LDClient
-    include Settings
+    include Evaluation
     #
     # Creates a new client instance that connects to LaunchDarkly. A custom
     # configuration parameter can also supplied to specify advanced options,
     # but for most use cases, the default configuration is appropriate.
     #
     #
-    # @param api_key [String] the API key for your LaunchDarkly account
+    # @param sdk_key [String] the SDK key for your LaunchDarkly account
     # @param config [Config] an optional client configuration object
     #
     # @return [LDClient] The LaunchDarkly client instance
-    def initialize(api_key, config = Config.default)
-      @queue = Queue.new
-      @api_key = api_key
+    def initialize(sdk_key, config = Config.default, wait_for_sec = 5)
+      @sdk_key = sdk_key
       @config = config
-      @client = Faraday.new do |builder|
-        builder.use :http_cache, store: @config.store
-
-        builder.adapter :net_http_persistent
-      end
-      @offline = false
-
-      if @config.stream?
-        @stream_processor = StreamProcessor.new(api_key, config)
+      @store = config.feature_store
+      requestor = Requestor.new(sdk_key, config)
+
+      if !@config.offline?
+        if @config.stream?
+          @update_processor = StreamProcessor.new(sdk_key, config, requestor)
+        else 
+          @update_processor = PollingProcessor.new(config, requestor)
+        end
+        @update_processor.start
       end
 
-      @worker = create_worker
-    end
+      @event_processor = EventProcessor.new(sdk_key, config)
 
-    def flush
-      events = []
-      begin
-        loop do
-          events << @queue.pop(true)
+      if !@config.offline? && wait_for_sec > 0
+        begin
+          WaitUtil.wait_for_condition("LaunchDarkly client initialization", :timeout_sec => wait_for_sec, :delay_sec => 0.1) do
+            @update_processor.initialized?
+          end
+        rescue WaitUtil::TimeoutError
+          @config.logger.error("[LDClient] Timeout encountered waiting for LaunchDarkly client initialization")
         end
-      rescue ThreadError
-      end
-
-      if !events.empty?
-        post_flushed_events(events)
       end
     end
 
-    def post_flushed_events(events)
-      res = log_timings("Flush events") do
-        next @client.post (@config.events_uri + "/bulk") do |req|
-          req.headers["Authorization"] = "api_key " + @api_key
-          req.headers["User-Agent"] = "RubyClient/" + LaunchDarkly::VERSION
-          req.headers["Content-Type"] = "application/json"
-          req.body = events.to_json
-          req.options.timeout = @config.read_timeout
-          req.options.open_timeout = @config.connect_timeout
-        end
-      end
-      if res.status / 100 != 2
-        @config.logger.error("[LDClient] Unexpected status code while processing events: #{res.status}")
-      end
+    def flush
+      @event_processor.flush
     end
 
-    def create_worker
-      Thread.new do
-        loop do
-          begin
-            flush
+    def toggle?(key, user, default = False)
+      @config.logger.warn("[LDClient] toggle? is deprecated. Use variation instead")
+      variation(key, user, default)
+    end
 
-            sleep(@config.flush_interval)
-          rescue StandardError => exn
-            log_exception(__method__.to_s, exn)
-          end
-        end
-      end
+    def secure_mode_hash(user)
+      OpenSSL::HMAC.hexdigest('sha256', @sdk_key, user[:key].to_s)
     end
 
-    def get_flag?(key, user, default = false)
-      toggle?(key, user, default)
+    # Returns whether the client has been initialized and is ready to serve feature flag requests
+    # @return [Boolean] true if the client has been initialized
+    def initialized?
+      @update_processor.initialized?
     end
 
     #
-    # Calculates the value of a feature flag for a given user. At a minimum,
+    # Determines the variation of a feature flag to present to a user. At a minimum,
     # the user hash should contain a +:key+ .
     #
     # @example Basic user hash
@@ -110,8 +87,6 @@ module LaunchDarkly
     # @example More complete user hash
     #   {key: "user@example.com", ip: "127.0.0.1", country: "US"}
     #
-    # Countries should be sent as ISO 3166-1 alpha-2 codes.
-    #
     # The user hash can contain arbitrary custom attributes stored in a +:custom+ sub-hash:
     #
     # @example A user hash with custom attributes
@@ -123,51 +98,53 @@ module LaunchDarkly
     # @param key [String] the unique feature key for the feature flag, as shown
     #   on the LaunchDarkly dashboard
     # @param user [Hash] a hash containing parameters for the end user requesting the flag
-    # @param default=false [Boolean] the default value of the flag
+    # @param default=false the default value of the flag
     #
-    # @return [Boolean] whether or not the flag should be enabled, or the
-    #   default value if the flag is disabled on the LaunchDarkly control panel
-    def toggle?(key, user, default = false)
-      return default if @offline
+    # @return the variation to show the user, or the
+    #   default value if there's an an error
+    def variation(key, user, default)
+      return default if @config.offline?
 
       unless user
         @config.logger.error("[LDClient] Must specify user")
+        @event_processor.add_event(kind: "feature", key: key, value: default, default: default, user: user)        
         return default
       end
-      sanitize_user(user)
-
-      if @config.stream? && !@stream_processor.started?
-        @stream_processor.start
-      end
 
-      if @config.stream? && @stream_processor.initialized?
-        feature = get_streamed_flag(key)
-      else
-        feature = get_flag_int(key)
+      if !@update_processor.initialized?
+        @config.logger.error("[LDClient] Client has not finished initializing. Returning default value")
+        @event_processor.add_event(kind: "feature", key: key, value: default, default: default, user: user)        
+        return default
       end
-      value = evaluate(feature, user)
-      value = value.nil? ? default : value
 
-      add_event(kind: "feature", key: key, user: user, value: value, default: default)
-      LDNewRelic.annotate_transaction(key, value)
-      return value
-    rescue StandardError => error
-      log_exception(__method__.to_s, error)
-      default
-    end
-
-    def add_event(event)
-      return if @offline
+      sanitize_user(user)
+      feature = @store.get(key)
 
-      if @queue.length < @config.capacity
-        event[:creationDate] = (Time.now.to_f * 1000).to_i
-        @queue.push(event)
+      if feature.nil?
+        @config.logger.error("[LDClient] Unknown feature flag #{key}. Returning default value")
+        @event_processor.add_event(kind: "feature", key: key, value: default, default: default, user: user)
+        return default
+      end
 
-        if !@worker.alive?
-          @worker = create_worker
+      begin
+        res = evaluate(feature, user, @store)
+        if !res[:events].nil?
+          res[:events].each do |event|
+            @event_processor.add_event(event)
+          end
         end
-      else
-        @config.logger.warn("[LDClient] Exceeded event queue capacity. Increase capacity to avoid dropping events.")
+        if !res[:value].nil?
+          @event_processor.add_event(kind: "feature", key: key, user: user, value: res[:value], default: default, version: feature[:version])
+          return res[:value]
+        else
+          @config.logger.debug("[LDClient] Result value is null in toggle")
+          @event_processor.add_event(kind: "feature", key: key, user: user, value: default, default: default, version: feature[:version])        
+          return default            
+        end
+      rescue => exn
+        @config.logger.warn("[LDClient] Error evaluating feature flag: #{exn.inspect}. \nTrace: #{exn.backtrace}")
+        @event_processor.add_event(kind: "feature", key: key, user: user, value: default, default: default, version: feature[:version])
+        return default
       end
     end
 
@@ -176,21 +153,10 @@ module LaunchDarkly
     #
     # @param [Hash] The user to register
     #
+    # @return [void]
     def identify(user)
       sanitize_user(user)
-      add_event(kind: "identify", key: user[:key], user: user)
-    end
-
-    def set_offline
-      @offline = true
-    end
-
-    def set_online
-      @offline = false
-    end
-
-    def is_offline?
-      @offline
+      @event_processor.add_event(kind: "identify", key: user[:key], user: user)
     end
 
     #
@@ -203,204 +169,30 @@ module LaunchDarkly
     # @return [void]
     def track(event_name, user, data)
       sanitize_user(user)
-      add_event(kind: "custom", key: event_name, user: user, data: data)
-    end
-
-    #
-    # Returns the key of every feature flag
-    #
-    def all_keys
-      all_flags.keys
+      @event_processor.add_event(kind: "custom", key: event_name, user: user, data: data)
     end
 
     #
-    # Returns all feature flags
+    # Returns all feature flag values for the given user
     #
-    def all_flags
-      return Hash.new if @offline
-
-      if @config.stream? && !@stream_processor.started?
-        @stream_processor.start
-      end
-
-      if @config.stream? && @stream_processor.initialized?
-        @stream_processor.get_all_features
-      else
-        res = make_request "/api/eval/features"
-
-        if res.status / 100 == 2
-          JSON.parse(res.body, symbolize_names: true)         
-        else
-          @config.logger.error("[LDClient] Unexpected status code #{res.status}")
-          Hash.new
-        end
-      end
-    end
-
-    def get_user_settings(user)
-      Hash[all_flags.map { |key, feature| [key, evaluate(feature, user)]}]
-    end
-
-    def get_streamed_flag(key)
-      feature = get_flag_stream(key)
-      if @config.debug_stream?
-        polled = get_flag_int(key)
-        diff = HashDiff.diff(feature, polled)
-        if not diff.empty?
-          @config.logger.error("Streamed flag differs from polled flag " + diff.to_s)
-        end
-      end
-      feature
-    end
-
-    def get_flag_stream(key)
-      @stream_processor.get_feature(key)
-    end
-
-    def get_flag_int(key)
-      res = log_timings("Feature request") do
-        next make_request "/api/eval/features/" + key
-      end
-
-      if res.status == 401
-        @config.logger.error("[LDClient] Invalid API key")
-        return nil
-      end
-
-      if res.status == 404
-        @config.logger.error("[LDClient] Unknown feature key: #{key}")
-        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
-
-    def make_request(path)
-      @client.get (@config.base_uri + path) do |req|
-        req.headers["Authorization"] = "api_key " + @api_key
-        req.headers["User-Agent"] = "RubyClient/" + LaunchDarkly::VERSION
-        req.options.timeout = @config.read_timeout
-        req.options.open_timeout = @config.connect_timeout
-      end
-    end
-
-    def param_for_user(feature, user)
-      return nil unless user[:key]
-
-      id_hash = user[:key]
-      if user[:secondary]
-        id_hash += "." + user[:secondary]
-      end
-
-      hash_key = "%s.%s.%s" % [feature[:key], feature[:salt], id_hash]
-
-      hash_val = (Digest::SHA1.hexdigest(hash_key))[0..14]
-      hash_val.to_i(16) / Float(0xFFFFFFFFFFFFFFF)
-    end
-
-    def match_target?(target, user)
-      attrib = target[:attribute].to_sym
-
-      if BUILTINS.include?(attrib)
-        return false unless user[attrib]
-
-        u_value = user[attrib]
-        return target[:values].include? u_value
-      else # custom attribute
-        return false unless user[:custom]
-        return false unless user[:custom].include? attrib
-
-        u_value = user[:custom][attrib]
-        if u_value.is_a? Array
-          return ! ((target[:values] & u_value).empty?)
-        else
-          return target[:values].include? u_value
-        end
-
-        return false
-      end
-    end
-
-    def match_user?(variation, user)
-      if variation[:userTarget]
-        return match_target?(variation[:userTarget], user)
-      end
-      false
-    end
-
-    def find_user_match(feature, user)
-      feature[:variations].each do |variation|
-        return variation[:value] if match_user?(variation, user)
-      end
-      nil
-    end
-
-    def match_variation?(variation, user)
-      variation[:targets].each do |target|
-        if !!variation[:userTarget] && target[:attribute].to_sym == :key
-          next
-        end
-
-        if match_target?(target, user)
-          return true
-        end
-      end
-      false
-    end
-
-    def find_target_match(feature, user)
-      feature[:variations].each do |variation|
-        return variation[:value] if match_variation?(variation, user)
-      end
-      nil
-    end
-
-    def find_weight_match(feature, param)
-      total = 0.0
-      feature[:variations].each do |variation|
-        total += variation[:weight].to_f / 100.0
+    def all_flags(user)
+      sanitize_user(user)
+      return Hash.new if @config.offline?
 
-        return variation[:value] if param < total
+      unless user
+        @config.logger.error("[LDClient] Must specify user in all_flags")
+        return Hash.new
       end
 
-      nil
-    end
-
-    def evaluate(feature, user)
-      return nil if feature.nil?
-      return nil unless feature[:on]
-
-      param = param_for_user(feature, user)
-      return nil if param.nil?
-
-      value = find_user_match(feature, user)
-      return value if !value.nil?
-
-      value = find_target_match(feature, user)
-      return value if !value.nil?
-
-      find_weight_match(feature, param)
-    end
+      begin
+        features = @store.all
 
-    def log_timings(label, &block)
-      return block.call unless @config.log_timings? && @config.logger.debug?
-      res = nil
-      exn = nil
-      bench = Benchmark.measure do
-        begin
-          res = block.call
-        rescue StandardError => e
-          exn = e
-        end
+        # TODO rescue if necessary
+        Hash[features.map{|k,f| [k, evaluate(f, user, @store)[:value]] }]
+      rescue => exn
+        @config.logger.warn("[LDClient] Error evaluating all flags: #{exn.inspect}. \nTrace: #{exn.backtrace}")
+        return Hash.new
       end
-      @config.logger.debug { "[LDClient] #{label} timing: #{bench}".chomp }
-      raise exn if exn
-      res
     end
 
     def log_exception(caller, exn)
@@ -415,9 +207,6 @@ module LaunchDarkly
       end
     end
 
-    private :post_flushed_events, :add_event, :get_streamed_flag,
-            :get_flag_stream, :get_flag_int, :make_request, :param_for_user,
-            :match_target?, :match_user?, :match_variation?, :evaluate,
-            :create_worker, :log_timings, :log_exception, :sanitize_user
+    private :evaluate, :log_exception, :sanitize_user
   end
 end