ldclient-rb 2.2.7 → 2.3.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 3e645183ee16963c519ab1ad307c7143c5d3a7e2
-  data.tar.gz: 91e57821ddab1cc9df9a30ec5ca25301a6ec97b9
+  metadata.gz: 8bfb8d22b2b4294ec4096d0c3131e20390bf2634
+  data.tar.gz: 42d06dbed907402e81213b207bbcf4ccce52dd5d
 SHA512:
-  metadata.gz: ee4f0da087bd1f0bcc900c9ff3e28239ad1d102a6e542b7d3349d72d0d5f23a6450e1040afbedfd0ad941bf6bab4f08f7bec7a8e11b7314464b2157b9a7128c0
-  data.tar.gz: 333cc4aa6a1a2ff95bfed3c7a71641d8162f11707a693ab3e14874b83ab732618de46b87c8e3dd9583e4130e0dfa1547362b4a1674dc70fd4c59330787869122
+  metadata.gz: d3b59e2fdbec17b31cc7c6450e1485afa9a522009990528b998f2f1782711049b86db19f56ba6212d09c931a23a5f92b1078fb70c071fd8adbbd1116990d8601
+  data.tar.gz: 6d2bdc142c97b704ed5ad211bb9eee18f3b0e2bf5deaf5ac2957b3d8fe8475f591e28bdc4ad604665b5154fbf96548fe058a6dbeeed4e98d9ed51320738c7994

data/CHANGELOG.md

@@ -2,6 +2,22 @@
 
 All notable changes to the LaunchDarkly Ruby SDK will be documented in this file. This project adheres to [Semantic Versioning](http://semver.org).
 
+## [2.3.1] - 2017-11-16
+
+### Changed
+- Include source code for changes described in 2.3.0
+
+
+## [2.3.0] - 2017-11-16
+## Added
+- Add `close` method to Ruby client to stop processing events
+- Add support for Redis feature store
+- Add support for LDD mode
+- Allow user to disable outgoing event stream.
+
+## Changed
+- Stop retrying on 401 responses (due to bad sdk keys)
+
 ## [2.2.7] - 2017-07-26
 ## Changed
 - Update Readme to fix instructions on installing gem using command line

data/CODEOWNERS

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

data/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:

data/ldclient-rb.gemspec

@@ -25,7 +25,10 @@ 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"
@@ -33,7 +36,7 @@ Gem::Specification.new do |spec|
   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"

data/lib/ldclient-rb.rb

@@ -6,6 +6,8 @@ require "ldclient-rb/config"
 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"

data/lib/ldclient-rb/config.rb

@@ -34,12 +34,23 @@ module LaunchDarkly
     # @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 @@ module LaunchDarkly
       @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 @@ module LaunchDarkly
       @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 @@ module LaunchDarkly
     #
     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 @@ module LaunchDarkly
       true
     end
 
+    def self.default_use_ldd
+      false
+    end
+
     def self.default_feature_store
       InMemoryFeatureStore.new
     end
@@ -220,5 +258,9 @@ module LaunchDarkly
     def self.default_poll_interval
       1
     end
+
+    def self.default_send_events
+      true
+    end
   end
 end

data/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

data/lib/ldclient-rb/events.rb

@@ -1,3 +1,4 @@
+require "concurrent/atomics"
 require "thread"
 require "faraday"
 
@@ -7,13 +8,28 @@ module LaunchDarkly
       @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 @@ module LaunchDarkly
         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 @@ module LaunchDarkly
       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

data/lib/ldclient-rb/feature_store.rb

@@ -55,5 +55,9 @@ module LaunchDarkly
     def initialized?
       @initialized.value
     end
+
+    def stop
+      # nothing to do
+    end
   end
 end

data/lib/ldclient-rb/ldclient.rb

@@ -27,6 +27,14 @@ module LaunchDarkly
       @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 @@ module LaunchDarkly
         @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 @@ module LaunchDarkly
     # 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 @@ module LaunchDarkly
         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 @@ module LaunchDarkly
       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}"

data/lib/ldclient-rb/polling.rb

@@ -8,6 +8,7 @@ module LaunchDarkly
       @requestor = requestor
       @initialized = Concurrent::AtomicBoolean.new(false)
       @started = Concurrent::AtomicBoolean.new(false)
+      @stopped = Concurrent::AtomicBoolean.new(false)
     end
 
     def initialized?
@@ -20,6 +21,15 @@ module LaunchDarkly
       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,9 +41,9 @@ module LaunchDarkly
     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
@@ -41,6 +51,9 @@ module LaunchDarkly
             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)

data/lib/ldclient-rb/redis_feature_store.rb

@@ -0,0 +1,234 @@
+require "concurrent/atomics"
+require "json"
+require "thread_safe"
+
+module LaunchDarkly
+  #
+  # An implementation of the LaunchDarkly client's feature store that uses a Redis
+  # instance.  Feature data can also be further cached in memory to reduce overhead
+  # of calls to Redis.
+  #
+  # To use this class, you must first have the `redis`, `connection-pool`, and `moneta`
+  # gems installed.  Then, create an instance and store it in the `feature_store`
+  # property of your client configuration.
+  #
+  class RedisFeatureStore
+    INIT_KEY = :"$initialized"
+
+    begin
+      require "redis"
+      require "connection_pool"
+      require "moneta"
+      REDIS_ENABLED = true
+    rescue ScriptError, StandardError
+      REDIS_ENABLED = false
+    end
+
+    #
+    # Constructor for a RedisFeatureStore instance.
+    #
+    # @param opts [Hash] the configuration options
+    # @option opts [String] :redis_url  URL of the Redis instance (shortcut for omitting redis_opts)
+    # @option opts [Hash] :redis_opts  options to pass to the Redis constructor (if you want to specify more than just redis_url)
+    # @option opts [String] :prefix  namespace prefix to add to all hash keys used by LaunchDarkly
+    # @option opts [Logger] :logger  a `Logger` instance; defaults to `Config.default_logger`
+    # @option opts [Integer] :max_connections  size of the Redis connection pool
+    # @option opts [Integer] :expiration  expiration time for the in-memory cache, in seconds; 0 for no local caching
+    # @option opts [Integer] :capacity  maximum number of feature flags to cache locally
+    # @option opts [Object] :pool  custom connection pool, used for testing only
+    #
+    def initialize(opts = {})
+      if !REDIS_ENABLED
+        raise RuntimeError.new("can't use RedisFeatureStore because one of these gems is missing: redis, connection_pool, moneta")
+      end
+      @redis_opts = opts[:redis_opts] || Hash.new
+      if opts[:redis_url]
+        @redis_opts[:url] = opts[:redis_url]
+      end
+      if !@redis_opts.include?(:url)
+        @redis_opts[:url] = RedisFeatureStore.default_redis_url
+      end
+      max_connections = opts[:max_connections] || 16
+      @pool = opts[:pool] || ConnectionPool.new(size: max_connections) do
+        Redis.new(@redis_opts)
+      end
+      @prefix = opts[:prefix] || RedisFeatureStore.default_prefix
+      @logger = opts[:logger] || Config.default_logger
+      @features_key = @prefix + ':features'
+
+      @expiration_seconds = opts[:expiration] || 15
+      @capacity = opts[:capacity] || 1000
+      # We're using Moneta only to provide expiration behavior for the in-memory cache.
+      # Moneta can also be used as a wrapper for Redis, but it doesn't support the Redis
+      # hash operations that we use.
+      if @expiration_seconds > 0
+        @cache = Moneta.new(:LRUHash, expires: true, threadsafe: true, max_count: @capacity)
+      else
+        @cache = Moneta.new(:Null)  # a stub that caches nothing
+      end
+
+      @stopped = Concurrent::AtomicBoolean.new(false)
+
+      with_connection do |redis|
+        @logger.info("RedisFeatureStore: using Redis instance at #{redis.connection[:host]}:#{redis.connection[:port]} \
+and prefix: #{@prefix}")
+      end
+    end
+
+    #
+    # Default value for the `redis_url` constructor parameter; points to an instance of Redis
+    # running at `localhost` with its default port.
+    #
+    def self.default_redis_url
+      'redis://localhost:6379/0'
+    end
+
+    #
+    # Default value for the `prefix` constructor parameter.
+    #
+    def self.default_prefix
+      'launchdarkly'
+    end
+
+    def get(key)
+      f = @cache[key.to_sym]
+      if f.nil?
+        @logger.debug("RedisFeatureStore: no cache hit for #{key}, requesting from Redis")
+        f = with_connection do |redis|
+          begin
+            get_redis(redis,key.to_sym)
+          rescue => e
+            @logger.error("RedisFeatureStore: could not retrieve feature #{key} from Redis, with error: #{e}")
+            nil
+          end
+        end
+        if !f.nil?
+          put_cache(key.to_sym, f)
+        end
+      end
+      if f.nil?
+        @logger.warn("RedisFeatureStore: feature #{key} not found")
+        nil
+      elsif f[:deleted]
+        @logger.warn("RedisFeatureStore: feature #{key} was deleted, returning nil")
+        nil
+      else
+        f
+      end
+    end
+
+    def all
+      fs = {}
+      with_connection do |redis|
+        begin
+          hashfs = redis.hgetall(@features_key)
+        rescue => e
+          @logger.error("RedisFeatureStore: could not retrieve all flags from Redis with error: #{e}; returning none")
+          hashfs = {}
+        end
+        hashfs.each do |k, jsonFeature|
+          f = JSON.parse(jsonFeature, symbolize_names: true)
+          if !f[:deleted]
+            fs[k.to_sym] = f
+          end
+        end
+      end
+      fs
+    end
+
+    def delete(key, version)
+      with_connection do |redis|
+        f = get_redis(redis, key)
+        if f.nil?
+          put_redis_and_cache(redis, key, { deleted: true, version: version })
+        else
+          if f[:version] < version
+            f1 = f.clone
+            f1[:deleted] = true
+            f1[:version] = version
+            put_redis_and_cache(redis, key, f1)
+          else
+            @logger.warn("RedisFeatureStore: attempted to delete flag: #{key} version: #{f[:version]} \
+  with a version that is the same or older: #{version}")
+          end
+        end
+      end
+    end
+
+    def init(fs)
+      @cache.clear
+      with_connection do |redis|
+        redis.del(@features_key)
+        fs.each { |k, f| put_redis_and_cache(redis, k, f) }
+      end
+      put_cache(INIT_KEY, true)
+      @logger.info("RedisFeatureStore: initialized with #{fs.count} feature flags")
+    end
+
+    def upsert(key, feature)
+      with_connection do |redis|
+        redis.watch(@features_key) do
+          old = get_redis(redis, key)
+          if old.nil? || (old[:version] < feature[:version])
+            put_redis_and_cache(redis, key, feature)
+          end
+          redis.unwatch
+        end
+      end
+    end
+
+    def initialized?
+      if @cache[INIT_KEY].nil?
+        if with_connection { |redis| redis.exists(@features_key) }
+          put_cache(INIT_KEY, true)
+          true
+        else
+          false
+        end
+      else
+        put_cache(INIT_KEY, true)  # reset TTL
+      end
+    end
+
+    def stop
+      if @stopped.make_true
+        @pool.shutdown { |redis| redis.close }
+        @cache.clear
+      end
+    end
+
+    # exposed for testing
+    def clear_local_cache()
+      @cache.clear
+    end
+
+    private
+
+    def with_connection
+      @pool.with { |redis| yield(redis) }
+    end
+
+    def get_redis(redis, key)
+      begin
+        json_feature = redis.hget(@features_key, key)
+        JSON.parse(json_feature, symbolize_names: true) if json_feature
+      rescue => e
+        @logger.error("RedisFeatureStore: could not retrieve feature #{key} from Redis, error: #{e}")
+        nil
+      end
+    end
+
+    def put_cache(key, value)
+      @cache.store(key, value, expires: @expiration_seconds)
+    end
+
+    def put_redis_and_cache(redis, key, feature)
+      begin
+        redis.hset(@features_key, key, feature.to_json)
+      rescue => e
+        @logger.error("RedisFeatureStore: could not store #{key} in Redis, error: #{e}")
+      end
+      put_cache(key.to_sym, feature)
+    end
+  end
+end

data/lib/ldclient-rb/requestor.rb

@@ -4,6 +4,9 @@ require "faraday/http_cache"
 
 module LaunchDarkly
 
+  class InvalidSDKKeyError < StandardError
+  end
+
   class Requestor
     def initialize(sdk_key, config)
       @sdk_key = sdk_key
@@ -39,7 +42,7 @@ module LaunchDarkly
 
       if res.status == 401
         @config.logger.error("[LDClient] Invalid SDK key")
-        return nil
+        raise InvalidSDKKeyError
       end
 
       if res.status == 404

data/lib/ldclient-rb/stream.rb

@@ -8,6 +8,7 @@ module LaunchDarkly
   DELETE = :delete
   INDIRECT_PUT = :'indirect/put'
   INDIRECT_PATCH = :'indirect/patch'
+  READ_TIMEOUT_SECONDS = 300  # 5 minutes; the stream should send a ping every 3 minutes
 
   class StreamProcessor
     def initialize(sdk_key, config, requestor)
@@ -17,6 +18,7 @@ module LaunchDarkly
       @requestor = requestor
       @initialized = Concurrent::AtomicBoolean.new(false)
       @started = Concurrent::AtomicBoolean.new(false)
+      @stopped = Concurrent::AtomicBoolean.new(false)
     end
 
     def initialized?
@@ -33,13 +35,34 @@ module LaunchDarkly
         'Authorization' => @sdk_key,
         'User-Agent' => 'RubyClient/' + LaunchDarkly::VERSION
       }
-      opts = {:headers => headers, :with_credentials => true, :proxy => @config.proxy}
+      opts = {:headers => headers, :with_credentials => true, :proxy => @config.proxy, :read_timeout => READ_TIMEOUT_SECONDS}
       @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 { |err|
+          @config.logger.error("[LDClient] Unexpected status code #{err[:status_code]} from streaming connection")
+          if err[:status_code] == 401
+            @config.logger.error("[LDClient] Received 401 error, no further streaming connection will be made since SDK key is invalid")
+            stop
+          end
+        }
+      end
+    end
+
+    def stop
+      if @stopped.make_true
+        @es.close
+        @config.logger.info("[LDClient] Stream connection stopped")
+      end
+    end
+
+    def stop
+      if @stopped.make_true
+        @es.close
+        @config.logger.info("[LDClient] Stream connection stopped")
       end
     end
 

data/lib/ldclient-rb/version.rb

@@ -1,3 +1,3 @@
 module LaunchDarkly
-  VERSION = "2.2.7"
+  VERSION = "2.3.1"
 end

data/spec/event_serializer_spec.rb

@@ -0,0 +1,86 @@
+require "spec_helper"
+
+describe LaunchDarkly::EventSerializer do
+  subject { LaunchDarkly::EventSerializer }
+
+  let(:base_config) { LaunchDarkly::Config.new }
+  let(:config_with_all_attrs_private) { LaunchDarkly::Config.new({ all_attributes_private: true })}
+  let(:config_with_some_attrs_private) { LaunchDarkly::Config.new({ private_attribute_names: ['firstName', 'bizzle'] })}
+
+  # users to serialize
+
+  let(:user) {
+    { key: 'abc', firstName: 'Sue', custom: { bizzle: 'def', dizzle: 'ghi' }}
+  }
+
+  let(:user_specifying_own_private_attr) {
+    u = user.clone
+    u[:privateAttributeNames] = [ 'dizzle', 'unused' ]
+    u
+  }
+
+  # expected results from serializing user
+
+  let(:user_with_all_attrs_hidden) {
+    { key: 'abc', custom: { }, privateAttrs: [ 'bizzle', 'dizzle', 'firstName' ]}
+  }
+
+  let(:user_with_some_attrs_hidden) {
+    { key: 'abc', custom: { dizzle: 'ghi' }, privateAttrs: [ 'bizzle', 'firstName' ]}
+  }
+
+  let(:user_with_own_specified_attr_hidden) {
+    { key: 'abc', firstName: 'Sue', custom: { bizzle: 'def' }, privateAttrs: [ '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]
+    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)]
+    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)]
+    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)]
+    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)]
+    end
+  end
+end

data/spec/feature_store_spec_base.rb

@@ -0,0 +1,112 @@
+require "spec_helper"
+
+RSpec.shared_examples "feature_store" do |create_store_method|
+
+  let(:feature0) {
+    {
+      key: "test-feature-flag",
+      version: 11,
+      on: true,
+      prerequisites: [],
+      salt: "718ea30a918a4eba8734b57ab1a93227",
+      sel: "fe1244e5378c4f99976c9634e33667c6",
+      targets: [
+        {
+           values: [ "alice" ],
+           variation: 0
+        },
+        {
+           values: [ "bob" ],
+           variation: 1
+        }
+      ],
+      rules: [],
+      fallthrough: { variation: 0 },
+      offVariation: 1,
+      variations: [ true, false ],
+      deleted: false
+    }
+  }
+  let(:key0) { feature0[:key].to_sym }
+
+  let!(:store) do
+    s = create_store_method.call()
+    s.init({ key0 => feature0 })
+    s
+  end
+
+  def new_version_plus(f, deltaVersion, attrs = {})
+    f1 = f.clone
+    f1[:version] = f[:version] + deltaVersion
+    f1.update(attrs)
+    f1
+  end
+
+
+  it "is initialized" do
+    expect(store.initialized?).to eq true
+  end
+
+  it "can get existing feature with symbol key" do
+    expect(store.get(key0)).to eq feature0
+  end
+
+  it "can get existing feature with string key" do
+    expect(store.get(key0.to_s)).to eq feature0
+  end
+
+  it "gets nil for nonexisting feature" do
+    expect(store.get('nope')).to be_nil
+  end
+
+  it "can get all features" do
+    feature1 = feature0.clone
+    feature1[:key] = "test-feature-flag1"
+    feature1[:version] = 5
+    feature1[:on] = false
+    store.upsert(:"test-feature-flag1", feature1)
+    expect(store.all).to eq ({ key0 => feature0, :"test-feature-flag1" => feature1 })
+  end
+
+  it "can add new feature" do
+    feature1 = feature0.clone
+    feature1[:key] = "test-feature-flag1"
+    feature1[:version] = 5
+    feature1[:on] = false
+    store.upsert(:"test-feature-flag1", feature1)
+    expect(store.get(:"test-feature-flag1")).to eq feature1
+  end
+
+  it "can update feature with newer version" do
+    f1 = new_version_plus(feature0, 1, { on: !feature0[:on] })
+    store.upsert(key0, f1)
+    expect(store.get(key0)).to eq f1
+  end
+
+  it "cannot update feature with same version" do
+    f1 = new_version_plus(feature0, 0, { on: !feature0[:on] })
+    store.upsert(key0, f1)
+    expect(store.get(key0)).to eq feature0
+  end
+
+  it "cannot update feature with older version" do
+    f1 = new_version_plus(feature0, -1, { on: !feature0[:on] })
+    store.upsert(key0, f1)
+    expect(store.get(key0)).to eq feature0
+  end
+
+  it "can delete feature with newer version" do
+    store.delete(key0, feature0[:version] + 1)
+    expect(store.get(key0)).to be_nil
+  end
+
+  it "cannot delete feature with same version" do
+    store.delete(key0, feature0[:version])
+    expect(store.get(key0)).to eq feature0
+  end
+
+  it "cannot delete feature with older version" do
+    store.delete(key0, feature0[:version] - 1)
+    expect(store.get(key0)).to eq feature0
+  end
+end

data/spec/fixtures/feature1.json

@@ -0,0 +1,36 @@
+{
+   "key":"test-feature-flag1",
+   "version":5,
+   "on":false,
+   "prerequisites":[
+
+   ],
+   "salt":"718ea30a918a4eba8734b57ab1a93227",
+   "sel":"fe1244e5378c4f99976c9634e33667c6",
+   "targets":[
+      {
+         "values":[
+            "alice"
+         ],
+         "variation":0
+      },
+      {
+         "values":[
+            "bob"
+         ],
+         "variation":1
+      }
+   ],
+   "rules":[
+
+   ],
+   "fallthrough":{
+      "variation":0
+   },
+   "offVariation":1,
+   "variations":[
+      true,
+      false
+   ],
+   "deleted":false
+}

data/spec/in_memory_feature_store_spec.rb

@@ -0,0 +1,12 @@
+require "feature_store_spec_base"
+require "spec_helper"
+
+def create_in_memory_store()
+  LaunchDarkly::InMemoryFeatureStore.new
+end
+
+describe LaunchDarkly::InMemoryFeatureStore do
+  subject { LaunchDarkly::InMemoryFeatureStore }
+  
+  include_examples "feature_store", method(:create_in_memory_store)
+end

data/spec/ldclient_spec.rb

@@ -70,4 +70,26 @@ describe LaunchDarkly::LDClient do
       end
     end
   end
+
+  describe 'with send_events: false' do
+    let(:config) { LaunchDarkly::Config.new({offline: true, send_events: false}) }
+    let(:client) { subject.new("secret", config) }
+
+    let(:queue) { client.instance_variable_get(:@event_processor).instance_variable_get(:@queue) }
+
+    it "does not enqueue a feature event" do
+      client.variation(feature[:key], user, "default")
+      expect(queue.empty?).to be true
+    end
+
+    it "does not enqueue a custom event" do
+      client.track("custom_event_name", user, 42)
+      expect(queue.empty?).to be true
+    end
+
+    it "does not enqueue an identify event" do
+      client.identify(user)
+      expect(queue.empty?).to be true
+    end
+  end
 end

data/spec/redis_feature_store_spec.rb

@@ -0,0 +1,43 @@
+require "feature_store_spec_base"
+require "json"
+require "spec_helper"
+
+
+
+$my_prefix = 'testprefix'
+$null_log = ::Logger.new($stdout)
+$null_log.level = ::Logger::FATAL
+
+
+def create_redis_store()
+  LaunchDarkly::RedisFeatureStore.new(prefix: $my_prefix, logger: $null_log, expiration: 60)
+end
+
+def create_redis_store_uncached()
+  LaunchDarkly::RedisFeatureStore.new(prefix: $my_prefix, logger: $null_log, expiration: 0)
+end
+
+
+describe LaunchDarkly::RedisFeatureStore do
+  subject { LaunchDarkly::RedisFeatureStore }
+  
+  let(:feature0_with_higher_version) do
+    f = feature0.clone
+    f[:version] = feature0[:version] + 10
+    f
+  end
+
+  # These tests will all fail if there isn't a Redis instance running on the default port.
+  
+  context "real Redis with local cache" do
+
+    include_examples "feature_store", method(:create_redis_store)
+
+  end
+
+  context "real Redis without local cache" do
+
+    include_examples "feature_store", method(:create_redis_store_uncached)
+
+  end
+end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: ldclient-rb
 version: !ruby/object:Gem::Version
-  version: 2.2.7
+  version: 2.3.1
 platform: ruby
 authors:
 - LaunchDarkly
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2017-07-26 00:00:00.000000000 Z
+date: 2017-11-16 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -66,6 +66,48 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '0'
+- !ruby/object:Gem::Dependency
+  name: redis
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 3.3.5
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 3.3.5
+- !ruby/object:Gem::Dependency
+  name: connection_pool
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 2.1.2
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 2.1.2
+- !ruby/object:Gem::Dependency
+  name: moneta
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 1.0.0
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 1.0.0
 - !ruby/object:Gem::Dependency
   name: json
   requirement: !ruby/object:Gem::Requirement
@@ -170,14 +212,14 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 0.10.0
+        version: 0.11.0
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 0.10.0
+        version: 0.11.0
 - !ruby/object:Gem::Dependency
   name: celluloid
   requirement: !ruby/object:Gem::Requirement
@@ -234,6 +276,7 @@ files:
 - ".rubocop.yml"
 - ".simplecov"
 - CHANGELOG.md
+- CODEOWNERS
 - CONTRIBUTING.md
 - Gemfile
 - LICENSE.txt
@@ -246,22 +289,29 @@ files:
 - 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/events.rb
 - lib/ldclient-rb/feature_store.rb
 - lib/ldclient-rb/ldclient.rb
 - lib/ldclient-rb/newrelic.rb
 - lib/ldclient-rb/polling.rb
+- lib/ldclient-rb/redis_feature_store.rb
 - lib/ldclient-rb/requestor.rb
 - lib/ldclient-rb/stream.rb
 - lib/ldclient-rb/version.rb
 - scripts/release.sh
 - spec/config_spec.rb
+- spec/event_serializer_spec.rb
+- spec/feature_store_spec_base.rb
 - spec/fixtures/feature.json
+- spec/fixtures/feature1.json
 - spec/fixtures/numeric_key_user.json
 - spec/fixtures/sanitized_numeric_key_user.json
 - spec/fixtures/user.json
+- spec/in_memory_feature_store_spec.rb
 - spec/ldclient_spec.rb
 - spec/newrelic_spec.rb
+- spec/redis_feature_store_spec.rb
 - spec/requestor_spec.rb
 - spec/spec_helper.rb
 - spec/store_spec.rb
@@ -293,12 +343,17 @@ specification_version: 4
 summary: LaunchDarkly SDK for Ruby
 test_files:
 - spec/config_spec.rb
+- spec/event_serializer_spec.rb
+- spec/feature_store_spec_base.rb
 - spec/fixtures/feature.json
+- spec/fixtures/feature1.json
 - spec/fixtures/numeric_key_user.json
 - spec/fixtures/sanitized_numeric_key_user.json
 - spec/fixtures/user.json
+- spec/in_memory_feature_store_spec.rb
 - spec/ldclient_spec.rb
 - spec/newrelic_spec.rb
+- spec/redis_feature_store_spec.rb
 - spec/requestor_spec.rb
 - spec/spec_helper.rb
 - spec/store_spec.rb