Merge branch 'master' into HEAD

Author: ashanbrown

CODEOWNERS

@@ -0,0 +1 @@
+* @ashanbrown

circle.yml

@@ -1,6 +1,8 @@
 machine:
   environment:
     RUBIES: "ruby-2.4.1;ruby-2.2.3;ruby-2.1.7;ruby-2.0.0;ruby-1.9.3;jruby-1.7.22" 
+  services:
+    - redis
 
 dependencies:
   cache_directories:

ldclient-rb.gemspec

@@ -25,15 +25,18 @@ Gem::Specification.new do |spec|
   spec.add_development_dependency "rake", "~> 10.0"
   spec.add_development_dependency "rspec", "~> 3.2"
   spec.add_development_dependency "codeclimate-test-reporter", "~> 0"
-
+  spec.add_development_dependency "redis", "~> 3.3.5"
+  spec.add_development_dependency "connection_pool", ">= 2.1.2"
+  spec.add_development_dependency "moneta", "~> 1.0.0"
+  
   spec.add_runtime_dependency "json", "~> 1.8"
   spec.add_runtime_dependency "faraday", "~> 0.9"
   spec.add_runtime_dependency "faraday-http-cache", "~> 1.3.0"
   spec.add_runtime_dependency "thread_safe", "~> 0.3"
   spec.add_runtime_dependency "net-http-persistent", "~> 2.9"
   spec.add_runtime_dependency "concurrent-ruby", "~> 1.0.4"
   spec.add_runtime_dependency "hashdiff", "~> 0.2"
-  spec.add_runtime_dependency "ld-celluloid-eventsource", "~> 0.10.0"
+  spec.add_runtime_dependency "ld-celluloid-eventsource", "~> 0.11.0"
   spec.add_runtime_dependency "celluloid", "~> 0.18.0.pre" # transitive dep; specified here for more control
 
   if RUBY_VERSION >= "2.2.2"

lib/ldclient-rb.rb

@@ -6,6 +6,8 @@
 require "ldclient-rb/newrelic"
 require "ldclient-rb/stream"
 require "ldclient-rb/polling"
+require "ldclient-rb/event_serializer"
 require "ldclient-rb/events"
 require "ldclient-rb/feature_store"
+require "ldclient-rb/redis_feature_store"
 require "ldclient-rb/requestor"

lib/ldclient-rb/config.rb

@@ -34,12 +34,23 @@ class Config
     # @option opts [Object] :cache_store A cache store for the Faraday HTTP caching
     #   library. Defaults to the Rails cache in a Rails environment, or a
     #   thread-safe in-memory store otherwise.
+    # @option opts [Boolean] :use_ldd (false) Whether you are using the LaunchDarkly relay proxy in
+    #   daemon mode. In this configuration, the client will not use a streaming connection to listen
+    #   for updates, but instead will get feature state from a Redis instance. The `stream` and
+    #   `poll_interval` options will be ignored if this option is set to true.
     # @option opts [Boolean] :offline (false) Whether the client should be initialized in 
     #   offline mode. In offline mode, default values are returned for all flags and no 
     #   remote network requests are made.
     # @option opts [Float] :poll_interval (1) The number of seconds between polls for flag updates
     #   if streaming is off.
     # @option opts [Boolean] :stream (true) Whether or not the streaming API should be used to receive flag updates.
+    # @option opts [Boolean] all_attributes_private (false) If true, all user attributes (other than the key)
+    #   will be private, not just the attributes specified in `private_attribute_names`.
+    # @option opts [Array] :private_attribute_names  Marks a set of attribute names private. Any users sent to
+    #  LaunchDarkly with this configuration active will have attributes with these names removed.
+    # @option opts [Boolean] :send_events (true) Whether or not to send events back to LaunchDarkly.
+    #   This differs from `offline` in that it affects only the sending of client-side events, not
+    #   streaming or polling for events from the server.
     #
     # @return [type] [description]
     # rubocop:disable Metrics/AbcSize, Metrics/PerceivedComplexity
@@ -55,9 +66,13 @@ def initialize(opts = {})
       @read_timeout = opts[:read_timeout] || Config.default_read_timeout
       @feature_store = opts[:feature_store] || Config.default_feature_store
       @stream = opts.has_key?(:stream) ? opts[:stream] : Config.default_stream
+      @use_ldd = opts.has_key?(:use_ldd) ? opts[:use_ldd] : Config.default_use_ldd
       @offline = opts.has_key?(:offline) ? opts[:offline] : Config.default_offline
       @poll_interval = opts.has_key?(:poll_interval) && opts[:poll_interval] > 1 ? opts[:poll_interval] : Config.default_poll_interval
       @proxy = opts[:proxy] || Config.default_proxy
+      @all_attributes_private = opts[:all_attributes_private] || false
+      @private_attribute_names = opts[:private_attribute_names] || []
+      @send_events = opts.has_key?(:send_events) ? opts[:send_events] : Config.default_send_events
     end
 
     #
@@ -87,6 +102,16 @@ def stream?
       @stream
     end
 
+    #
+    # Whether to use the LaunchDarkly relay proxy in daemon mode. In this mode, we do
+    # not use polling or streaming to get feature flag updates from the server, but instead
+    # read them from a Redis instance that is updated by the proxy.
+    #
+    # @return [Boolean] True if using the LaunchDarkly relay proxy in daemon mode
+    def use_ldd?
+      @use_ldd
+    end
+    
     # TODO docs
     def offline?
       @offline
@@ -150,6 +175,15 @@ def offline?
     #
     attr_reader :proxy
 
+    attr_reader :all_attributes_private
+
+    attr_reader :private_attribute_names
+    
+    #
+    # Whether to send events back to LaunchDarkly.
+    #
+    attr_reader :send_events
+
     #
     # The default LaunchDarkly client configuration. This configuration sets
     # reasonable defaults for most users.
@@ -209,6 +243,10 @@ def self.default_stream
       true
     end
 
+    def self.default_use_ldd
+      false
+    end
+
     def self.default_feature_store
       InMemoryFeatureStore.new
     end
@@ -220,5 +258,9 @@ def self.default_offline
     def self.default_poll_interval
       1
     end
+
+    def self.default_send_events
+      true
+    end
   end
 end

lib/ldclient-rb/event_serializer.rb

@@ -0,0 +1,51 @@
+require "json"
+
+module LaunchDarkly
+  class EventSerializer
+    def initialize(config)
+      @all_attributes_private = config.all_attributes_private
+      @private_attribute_names = Set.new(config.private_attribute_names.map(&:to_sym))
+    end
+
+    def serialize_events(events)
+      events.map { |event|
+        Hash[event.map { |key, value|
+          [key, (key.to_sym == :user) ? transform_user_props(value) : value]
+        }]
+      }.to_json
+    end
+
+    private
+
+    IGNORED_TOP_LEVEL_KEYS = Set.new([:custom, :key, :privateAttributeNames])
+    STRIPPED_TOP_LEVEL_KEYS = Set.new([:privateAttributeNames])
+
+    def filter_values(props, user_private_attrs, ignore=[])
+      removed_keys = Set.new(props.keys.select { |key|
+        !ignore.include?(key) && private_attr?(key, user_private_attrs)
+      })
+      filtered_hash = props.select { |key, value| !removed_keys.include?(key) && !STRIPPED_TOP_LEVEL_KEYS.include?(key) }
+      [filtered_hash, removed_keys]
+    end
+
+    def private_attr?(name, user_private_attrs)
+      @all_attributes_private || @private_attribute_names.include?(name) || user_private_attrs.include?(name)
+    end
+
+    def transform_user_props(user_props)
+      user_private_attrs = Set.new((user_props[:privateAttributeNames] || []).map(&:to_sym))
+
+      filtered_user_props, removed = filter_values(user_props, user_private_attrs, IGNORED_TOP_LEVEL_KEYS)
+      if user_props.has_key?(:custom)
+        filtered_user_props[:custom], removed_custom = filter_values(user_props[:custom], user_private_attrs)
+        removed.merge(removed_custom)
+      end
+
+      unless removed.empty?
+        # note, :privateAttributeNames is what the developer sets; :privateAttrs is what we send to the server
+        filtered_user_props[:privateAttrs] = removed.to_a.sort
+      end
+      return filtered_user_props
+    end
+  end
+end

lib/ldclient-rb/events.rb

@@ -1,3 +1,4 @@
+require "concurrent/atomics"
 require "thread"
 require "faraday"
 
@@ -7,13 +8,28 @@ def initialize(sdk_key, config)
       @queue = Queue.new
       @sdk_key = sdk_key
       @config = config
+      @serializer = EventSerializer.new(config)
       @client = Faraday.new
-      @worker = create_worker
+      @stopped = Concurrent::AtomicBoolean.new(false)
+      @worker = create_worker if @config.send_events
+    end
+
+    def alive?
+      !@stopped.value
+    end
+
+    def stop
+      if @stopped.make_true
+        # There seems to be no such thing as "close" in Faraday: https://github.com/lostisland/faraday/issues/241
+        if !@worker.nil? && @worker.alive?
+          @worker.raise "shutting down client"
+        end
+      end
     end
 
     def create_worker
       Thread.new do
-        loop do
+        while !@stopped.value do
           begin
             flush
             sleep(@config.flush_interval)
@@ -29,16 +45,21 @@ def post_flushed_events(events)
         req.headers["Authorization"] = @sdk_key
         req.headers["User-Agent"] = "RubyClient/" + LaunchDarkly::VERSION
         req.headers["Content-Type"] = "application/json"
-        req.body = events.to_json
+        req.body = @serializer.serialize_events(events)
         req.options.timeout = @config.read_timeout
         req.options.open_timeout = @config.connect_timeout
       end
       if res.status < 200 || res.status >= 300
         @config.logger.error("[LDClient] Unexpected status code while processing events: #{res.status}")
+        if res.status == 401
+          @config.logger.error("[LDClient] Received 401 error, no further events will be posted since SDK key is invalid")
+          stop
+        end
       end
     end
 
     def flush
+      return if @offline || !@config.send_events
       events = []
       begin
         loop do
@@ -47,13 +68,13 @@ def flush
       rescue ThreadError
       end
 
-      if !events.empty?
+      if !events.empty? && !@stopped.value
         post_flushed_events(events)
       end
     end
 
     def add_event(event)
-      return if @offline
+      return if @offline || !@config.send_events || @stopped.value
 
       if @queue.length < @config.capacity
         event[:creationDate] = (Time.now.to_f * 1000).to_i

lib/ldclient-rb/feature_store.rb

@@ -55,5 +55,9 @@ def upsert(key, feature)
     def initialized?
       @initialized.value
     end
+
+    def stop
+      # nothing to do
+    end
   end
 end

lib/ldclient-rb/ldclient.rb

@@ -27,6 +27,14 @@ def initialize(sdk_key, config = Config.default, wait_for_sec = 5)
       @sdk_key = sdk_key
       @config = config
       @store = config.feature_store
+
+      @event_processor = EventProcessor.new(sdk_key, config)
+
+      if @config.use_ldd?
+        @config.logger.info("[LDClient] Started LaunchDarkly Client in LDD mode")
+        return  # requestor and update processor are not used in this mode
+      end
+
       requestor = Requestor.new(sdk_key, config)
 
       if !@config.offline?
@@ -38,8 +46,6 @@ def initialize(sdk_key, config = Config.default, wait_for_sec = 5)
         @update_processor.start
       end
 
-      @event_processor = EventProcessor.new(sdk_key, config)
-
       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
@@ -67,7 +73,7 @@ def secure_mode_hash(user)
     # 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?
+      @config.offline? || @config.use_ldd? || @update_processor.initialized?
     end
 
     #
@@ -111,7 +117,7 @@ def variation(key, user, default)
         return default
       end
 
-      if !@update_processor.initialized?
+      if !@update_processor.nil? && !@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
@@ -195,6 +201,19 @@ def all_flags(user)
       end
     end
 
+    #
+    # Releases all network connections and other resources held by the client, making it no longer usable
+    #
+    # @return [void]
+    def close
+      @config.logger.info("[LDClient] Closing LaunchDarkly client...")
+      if not @config.offline?
+        @update_processor.stop
+      end
+      @event_processor.stop
+      @store.stop
+    end
+
     def log_exception(caller, exn)
       error_traceback = "#{exn.inspect} #{exn}\n\t#{exn.backtrace.join("\n\t")}"
       error = "[LDClient] Unexpected exception in #{caller}: #{error_traceback}"

lib/ldclient-rb/polling.rb

@@ -8,6 +8,7 @@ def initialize(config, requestor)
       @requestor = requestor
       @initialized = Concurrent::AtomicBoolean.new(false)
       @started = Concurrent::AtomicBoolean.new(false)
+      @stopped = Concurrent::AtomicBoolean.new(false)
     end
 
     def initialized?
@@ -20,6 +21,15 @@ def start
       create_worker
     end
 
+    def stop
+      if @stopped.make_true
+        if @worker && @worker.alive?
+          @worker.raise "shutting down client"
+        end
+        @config.logger.info("[LDClient] Polling connection stopped")
+      end
+    end
+
     def poll
       flags = @requestor.request_all_flags
       if flags
@@ -31,16 +41,19 @@ def poll
     end
 
     def create_worker
-      Thread.new do
+      @worker = Thread.new do
         @config.logger.debug("[LDClient] Starting polling worker")
-        loop do
+        while !@stopped.value do
           begin
             started_at = Time.now
             poll
             delta = @config.poll_interval - (Time.now - started_at)
             if delta > 0
               sleep(delta)
             end
+          rescue InvalidSDKKeyError
+            @config.logger.error("[LDClient] Received 401 error, no further polling requests will be made since SDK key is invalid");
+            stop
           rescue StandardError => exn
             @config.logger.error("[LDClient] Exception while polling: #{exn.inspect}")
             # TODO: log_exception(__method__.to_s, exn)