ldclient-rb 5.3.0 → 5.4.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: c11f5029a26f9320594fad4b3e580add838f46dd
-  data.tar.gz: e9d8569a3f7b96a0cdbbc7ecedc1f76b798c8f1f
+  metadata.gz: 1638ba1d1609d7d8a027f23a679da4fda6112ff2
+  data.tar.gz: cd6bd5a3a4a24d2e69174a76c4cff1bfe75d54ec
 SHA512:
-  metadata.gz: 55780c3aec6537b3491fe4c960a7475a29c3ea529b337ad3f3556140c9faa949c2de44340837ef1d3f069b043aa2e80de05a790e575f0b868b5c3e382c076cb6
-  data.tar.gz: aac072bbc8e7dc99c64ee282da1dd735c87d5f76518dab6e5c1ca3e86dfd11148b4b53e44ac40624b0db61a2fba61acc1b9fa2dacec595d71d4082505f3e3f3a
+  metadata.gz: 3d26b16c922b72855188f6d6f8e1205538dd46ffce2af1699989a65b32dcfb15cb7fe696c3217d96b43e77bbeb66a29f3bab5c1d055ff5f6b20599827261f8d7
+  data.tar.gz: 866d5aad4cba770fb7aaf5c82dfecd934c115cb3801bf8941b06646adde1ce07e0d2c3be98296bfc42fe13f6363f26ad91dfdb67c3038a486618326d82cc68b5

data/CHANGELOG.md

@@ -2,6 +2,18 @@
 
 All notable changes to the LaunchDarkly Ruby SDK will be documented in this file. This project adheres to [Semantic Versioning](http://semver.org).
 
+## [5.4.1] - 2018-11-05
+### Fixed:
+* Fixed a `LoadError` in `file_data_source.rb`, which was added in 5.4.0. (Thanks, [kbarrette](https://github.com/launchdarkly/ruby-client/pull/110)!)
+
+
+## [5.4.0] - 2018-11-02
+### Added:
+- It is now possible to inject feature flags into the client from local JSON or YAML files, replacing the normal LaunchDarkly connection. This would typically be for testing purposes. See `file_data_source.rb`.
+
+### Fixed:
+- When shutting down an `LDClient`, if in polling mode, the client was using `Thread.raise` to make the polling thread stop sleeping. `Thread.raise` can cause unpredictable behavior in a worker thread, so it is no longer used.
+
 ## [5.3.0] - 2018-10-24
 ### Added:
 - The `all_flags_state` method now accepts a new option, `details_only_for_tracked_flags`, which reduces the size of the JSON representation of the flag state by omitting some metadata. Specifically, it omits any data that is normally used for generating detailed evaluation events if a flag does not have event tracking or debugging turned on.

data/README.md

@@ -121,6 +121,10 @@ else
 end
 ```
 
+Using flag data from a file
+---------------------------
+For testing purposes, the SDK can be made to read feature flag state from a file or files instead of connecting to LaunchDarkly. See [`file_data_source.rb`](https://github.com/launchdarkly/ruby-client/blob/master/lib/ldclient-rb/file_data_source.rb) for more details.
+
 Learn more
 -----------
 

data/ldclient-rb.gemspec

@@ -29,6 +29,7 @@ Gem::Specification.new do |spec|
   spec.add_development_dependency "rake", "~> 10.0"
   spec.add_development_dependency "rspec_junit_formatter", "~> 0.3.0"
   spec.add_development_dependency "timecop", "~> 0.9.1"
+  spec.add_development_dependency "listen", "~> 3.0" # see file_data_source.rb
 
   spec.add_runtime_dependency "json", [">= 1.8", "< 3"]
   spec.add_runtime_dependency "faraday", [">= 0.9", "< 2"]

data/lib/ldclient-rb.rb

@@ -18,3 +18,4 @@ require "ldclient-rb/event_summarizer"
 require "ldclient-rb/events"
 require "ldclient-rb/redis_store"
 require "ldclient-rb/requestor"
+require "ldclient-rb/file_data_source"

data/lib/ldclient-rb/config.rb

@@ -61,8 +61,11 @@ module LaunchDarkly
     # @option opts [Boolean] :inline_users_in_events (false) Whether to include full user details in every
     #   analytics event. By default, events will only include the user key, except for one "index" event
     #   that provides the full details for the user.
-    # @option opts [Object] :update_processor An object that will receive feature flag data from LaunchDarkly.
-    #   Defaults to either the streaming or the polling processor, can be customized for tests.
+    # @option opts [Object] :update_processor (DEPRECATED) An object that will receive feature flag data from
+    #   LaunchDarkly. Defaults to either the streaming or the polling processor, can be customized for tests.
+    # @option opts [Object] :update_processor_factory A function that takes the SDK and configuration object
+    #   as parameters, and returns an object that can obtain feature flag data and put it into the feature
+    #   store. Defaults to creating either the streaming or the polling processor, can be customized for tests.
     # @return [type] [description]
     # rubocop:disable Metrics/AbcSize, Metrics/PerceivedComplexity
     def initialize(opts = {})
@@ -88,6 +91,7 @@ module LaunchDarkly
       @user_keys_flush_interval = opts[:user_keys_flush_interval] || Config.default_user_keys_flush_interval
       @inline_users_in_events = opts[:inline_users_in_events] || false
       @update_processor = opts[:update_processor]
+      @update_processor_factory = opts[:update_processor_factory]
     end
 
     #
@@ -218,6 +222,8 @@ module LaunchDarkly
 
     attr_reader :update_processor
     
+    attr_reader :update_processor_factory
+    
     #
     # The default LaunchDarkly client configuration. This configuration sets
     # reasonable defaults for most users.

data/lib/ldclient-rb/file_data_source.rb

@@ -0,0 +1,307 @@
+require 'concurrent/atomics'
+require 'json'
+require 'yaml'
+require 'pathname'
+
+module LaunchDarkly
+  # To avoid pulling in 'listen' and its transitive dependencies for people who aren't using the
+  # file data source or who don't need auto-updating, we only enable auto-update if the 'listen'
+  # gem has been provided by the host app.
+  @@have_listen = false
+  begin
+    require 'listen'
+    @@have_listen = true
+  rescue LoadError
+  end
+  def self.have_listen?
+    @@have_listen
+  end
+
+  #
+  # Provides a way to use local files as a source of feature flag state. This would typically be
+  # used in a test environment, to operate using a predetermined feature flag state without an
+  # actual LaunchDarkly connection.
+  #
+  # To use this component, call `FileDataSource.factory`, and store its return value in the
+  # `update_processor_factory` property of your LaunchDarkly client configuration. In the options
+  # to `factory`, set `paths` to the file path(s) of your data file(s):
+  #
+  #     factory = FileDataSource.factory(paths: [ myFilePath ])
+  #     config = LaunchDarkly::Config.new(update_processor_factory: factory)
+  #
+  # This will cause the client not to connect to LaunchDarkly to get feature flags. The
+  # client may still make network connections to send analytics events, unless you have disabled
+  # this with Config.send_events or Config.offline.
+  #
+  # Flag data files can be either JSON or YAML. They contain an object with three possible
+  # properties:
+  #
+  # - "flags": Feature flag definitions.
+  # - "flagValues": Simplified feature flags that contain only a value.
+  # - "segments": User segment definitions.
+  #
+  # The format of the data in "flags" and "segments" is defined by the LaunchDarkly application
+  # and is subject to change. Rather than trying to construct these objects yourself, it is simpler
+  # to request existing flags directly from the LaunchDarkly server in JSON format, and use this
+  # output as the starting point for your file. In Linux you would do this:
+  #
+  #    curl -H "Authorization: {your sdk key}" https://app.launchdarkly.com/sdk/latest-all
+  #
+  # The output will look something like this (but with many more properties):
+  #
+  #     {
+  #       "flags": {
+  #         "flag-key-1": {
+  #           "key": "flag-key-1",
+  #           "on": true,
+  #           "variations": [ "a", "b" ]
+  #         }
+  #       },
+  #       "segments": {
+  #         "segment-key-1": {
+  #           "key": "segment-key-1",
+  #           "includes": [ "user-key-1" ]
+  #         }
+  #       }
+  #     }
+  #
+  # Data in this format allows the SDK to exactly duplicate all the kinds of flag behavior supported
+  # by LaunchDarkly. However, in many cases you will not need this complexity, but will just want to
+  # set specific flag keys to specific values. For that, you can use a much simpler format:
+  #
+  #     {
+  #       "flagValues": {
+  #         "my-string-flag-key": "value-1",
+  #         "my-boolean-flag-key": true,
+  #         "my-integer-flag-key": 3
+  #       }
+  #     }
+  #
+  # Or, in YAML:
+  #
+  #     flagValues:
+  #       my-string-flag-key: "value-1"
+  #       my-boolean-flag-key: true
+  #       my-integer-flag-key: 1
+  #
+  # It is also possible to specify both "flags" and "flagValues", if you want some flags
+  # to have simple values and others to have complex behavior. However, it is an error to use the
+  # same flag key or segment key more than once, either in a single file or across multiple files.
+  #
+  # If the data source encounters any error in any file-- malformed content, a missing file, or a
+  # duplicate key-- it will not load flags from any of the files.      
+  #
+  class FileDataSource
+    #
+    # Returns a factory for the file data source component.
+    #
+    # @param options [Hash] the configuration options
+    # @option options [Array] :paths  The paths of the source files for loading flag data. These
+    #   may be absolute paths or relative to the current working directory.
+    # @option options [Boolean] :auto_update  True if the data source should watch for changes to
+    #   the source file(s) and reload flags whenever there is a change. Auto-updating will only
+    #   work if all of the files you specified have valid directory paths at startup time.
+    #   Note that the default implementation of this feature is based on polling the filesystem,
+    #   which may not perform well. If you install the 'listen' gem (not included by default, to
+    #   avoid adding unwanted dependencies to the SDK), its native file watching mechanism will be
+    #   used instead. However, 'listen' will not be used in JRuby 9.1 due to a known instability.
+    # @option options [Float] :poll_interval  The minimum interval, in seconds, between checks for
+    #   file modifications - used only if auto_update is true, and if the native file-watching
+    #   mechanism from 'listen' is not being used. The default value is 1 second.
+    #
+    def self.factory(options={})
+      return Proc.new do |sdk_key, config|
+        FileDataSourceImpl.new(config.feature_store, config.logger, options)
+      end
+    end
+  end
+
+  class FileDataSourceImpl
+    def initialize(feature_store, logger, options={})
+      @feature_store = feature_store
+      @logger = logger
+      @paths = options[:paths] || []
+      if @paths.is_a? String
+        @paths = [ @paths ]
+      end
+      @auto_update = options[:auto_update]
+      if @auto_update && LaunchDarkly.have_listen? && !options[:force_polling] # force_polling is used only for tests
+        # We have seen unreliable behavior in the 'listen' gem in JRuby 9.1 (https://github.com/guard/listen/issues/449).
+        # Therefore, on that platform we'll fall back to file polling instead.
+        if defined?(JRUBY_VERSION) && JRUBY_VERSION.start_with?("9.1.")
+          @use_listen = false
+        else
+          @use_listen = true
+        end
+      end
+      @poll_interval = options[:poll_interval] || 1
+      @initialized = Concurrent::AtomicBoolean.new(false)
+      @ready = Concurrent::Event.new
+    end
+
+    def initialized?
+      @initialized.value
+    end
+
+    def start
+      ready = Concurrent::Event.new
+      
+      # We will return immediately regardless of whether the file load succeeded or failed -
+      # the difference can be detected by checking "initialized?"
+      ready.set
+
+      load_all
+
+      if @auto_update
+        # If we're going to watch files, then the start event will be set the first time we get
+        # a successful load.
+        @listener = start_listener
+      end
+
+      ready
+    end
+    
+    def stop
+      @listener.stop if !@listener.nil?
+    end
+
+    private
+
+    def load_all
+      all_data = {
+        FEATURES => {},
+        SEGMENTS => {}
+      }
+      @paths.each do |path|
+        begin
+          load_file(path, all_data)
+        rescue => exn
+          Util.log_exception(@logger, "Unable to load flag data from \"#{path}\"", exn)
+          return
+        end
+      end
+      @feature_store.init(all_data)
+      @initialized.make_true
+    end
+
+    def load_file(path, all_data)
+      parsed = parse_content(IO.read(path))
+      (parsed[:flags] || {}).each do |key, flag|
+        add_item(all_data, FEATURES, flag)
+      end
+      (parsed[:flagValues] || {}).each do |key, value|
+        add_item(all_data, FEATURES, make_flag_with_value(key.to_s, value))
+      end
+      (parsed[:segments] || {}).each do |key, segment|
+        add_item(all_data, SEGMENTS, segment)
+      end
+    end
+
+    def parse_content(content)
+      # We can use the Ruby YAML parser for both YAML and JSON (JSON is a subset of YAML and while
+      # not all YAML parsers handle it correctly, we have verified that the Ruby one does, at least
+      # for all the samples of actual flag data that we've tested).
+      symbolize_all_keys(YAML.load(content))
+    end
+
+    def symbolize_all_keys(value)
+      # This is necessary because YAML.load doesn't have an option for parsing keys as symbols, and
+      # the SDK expects all objects to be formatted that way.
+      if value.is_a?(Hash)
+        value.map{ |k, v| [k.to_sym, symbolize_all_keys(v)] }.to_h
+      elsif value.is_a?(Array)
+        value.map{ |v| symbolize_all_keys(v) }
+      else
+        value
+      end
+    end
+
+    def add_item(all_data, kind, item)
+      items = all_data[kind]
+      raise ArgumentError, "Received unknown item kind #{kind} in add_data" if items.nil? # shouldn't be possible since we preinitialize the hash
+      key = item[:key].to_sym
+      if !items[key].nil?
+        raise ArgumentError, "#{kind[:namespace]} key \"#{item[:key]}\" was used more than once"
+      end
+      items[key] = item
+    end
+
+    def make_flag_with_value(key, value)
+      {
+        key: key,
+        on: true,
+        fallthrough: { variation: 0 },
+        variations: [ value ]
+      }
+    end
+
+    def start_listener
+      resolved_paths = @paths.map { |p| Pathname.new(File.absolute_path(p)).realpath.to_s }
+      if @use_listen
+        start_listener_with_listen_gem(resolved_paths)
+      else
+        FileDataSourcePoller.new(resolved_paths, @poll_interval, self.method(:load_all), @logger)
+      end
+    end
+
+    def start_listener_with_listen_gem(resolved_paths)
+      path_set = resolved_paths.to_set
+      dir_paths = resolved_paths.map{ |p| File.dirname(p) }.uniq
+      opts = { latency: @poll_interval }
+      l = Listen.to(*dir_paths, opts) do |modified, added, removed|
+        paths = modified + added + removed
+        if paths.any? { |p| path_set.include?(p) }
+          load_all
+        end
+      end
+      l.start
+      l
+    end
+
+    #
+    # Used internally by FileDataSource to track data file changes if the 'listen' gem is not available.
+    #
+    class FileDataSourcePoller
+      def initialize(resolved_paths, interval, reloader, logger)
+        @stopped = Concurrent::AtomicBoolean.new(false)
+        get_file_times = Proc.new do
+          ret = {}
+          resolved_paths.each do |path|
+            begin
+              ret[path] = File.mtime(path)
+            rescue Errno::ENOENT
+              ret[path] = nil
+            end
+          end
+          ret
+        end
+        last_times = get_file_times.call
+        @thread = Thread.new do
+          while true
+            sleep interval
+            break if @stopped.value
+            begin
+              new_times = get_file_times.call
+              changed = false
+              last_times.each do |path, old_time|
+                new_time = new_times[path]
+                if !new_time.nil? && new_time != old_time
+                  changed = true
+                  break
+                end
+              end
+              reloader.call if changed
+            rescue => exn
+              Util.log_exception(logger, "Unexpected exception in FileDataSourcePoller", exn)
+            end
+          end
+        end
+      end
+
+      def stop
+        @stopped.make_true
+        @thread.run  # wakes it up if it's sleeping
+      end
+    end
+  end
+end

data/lib/ldclient-rb/ldclient.rb

@@ -39,22 +39,11 @@ module LaunchDarkly
         return  # requestor and update processor are not used in this mode
       end
 
-      requestor = Requestor.new(sdk_key, config)
-
-      if @config.offline?
-        @update_processor = NullUpdateProcessor.new
+      if @config.update_processor
+        @update_processor = @config.update_processor
       else
-        if @config.update_processor.nil?
-          if @config.stream?
-            @update_processor = StreamProcessor.new(sdk_key, config, requestor)
-          else
-            @config.logger.info { "Disabling streaming API" }
-            @config.logger.warn { "You should only disable the streaming API if instructed to do so by LaunchDarkly support" }
-            @update_processor = PollingProcessor.new(config, requestor)
-          end
-        else
-          @update_processor = @config.update_processor
-        end
+        factory = @config.update_processor_factory || self.method(:create_default_update_processor)
+        @update_processor = factory.call(sdk_key, config)
       end
 
       ready = @update_processor.start
@@ -269,6 +258,20 @@ module LaunchDarkly
 
     private
 
+    def create_default_update_processor(sdk_key, config)
+      if config.offline?
+        return NullUpdateProcessor.new
+      end
+      requestor = Requestor.new(sdk_key, config)
+      if config.stream?
+        StreamProcessor.new(sdk_key, config, requestor)
+      else
+        config.logger.info { "Disabling streaming API" }
+        config.logger.warn { "You should only disable the streaming API if instructed to do so by LaunchDarkly support" }
+        PollingProcessor.new(config, requestor)
+      end
+    end
+
     # @return [EvaluationDetail]
     def evaluate_internal(key, user, default, include_reasons_in_events)
       if @config.offline?

data/lib/ldclient-rb/polling.rb

@@ -26,7 +26,8 @@ module LaunchDarkly
     def stop
       if @stopped.make_true
         if @worker && @worker.alive?
-          @worker.raise "shutting down client"
+          @worker.run  # causes the thread to wake up if it's currently in a sleep
+          @worker.join
         end
         @config.logger.info { "[LDClient] Polling connection stopped" }
       end

data/lib/ldclient-rb/version.rb

@@ -1,3 +1,3 @@
 module LaunchDarkly
-  VERSION = "5.3.0"
+  VERSION = "5.4.1"
 end

data/spec/file_data_source_spec.rb

@@ -0,0 +1,255 @@
+require "spec_helper"
+require "tempfile"
+
+describe LaunchDarkly::FileDataSource do
+  let(:full_flag_1_key) { "flag1" }
+  let(:full_flag_1_value) { "on" }
+  let(:flag_value_1_key) { "flag2" }
+  let(:flag_value_1) { "value2" }
+  let(:all_flag_keys) { [ full_flag_1_key.to_sym, flag_value_1_key.to_sym ] }
+  let(:full_segment_1_key) { "seg1" }
+  let(:all_segment_keys) { [ full_segment_1_key.to_sym ] }
+
+  let(:flag_only_json) { <<-EOF
+  {
+    "flags": {
+      "flag1": {
+        "key": "flag1",
+        "on": true,
+        "fallthrough": {
+          "variation": 2
+        },
+        "variations": [ "fall", "off", "on" ]
+      }
+    }
+  }
+EOF
+  }
+
+  let(:segment_only_json) { <<-EOF
+  {
+    "segments": {
+      "seg1": {
+        "key": "seg1",
+        "include": ["user1"]
+      }
+    }
+  }
+EOF
+  }
+
+  let(:all_properties_json) { <<-EOF
+  {
+    "flags": {
+      "flag1": {
+        "key": "flag1",
+        "on": true,
+        "fallthrough": {
+          "variation": 2
+        },
+        "variations": [ "fall", "off", "on" ]
+      }
+    },
+    "flagValues": {
+      "flag2": "value2"
+    },
+    "segments": {
+      "seg1": {
+        "key": "seg1",
+        "include": ["user1"]
+      }
+    }
+  }
+EOF
+  }
+
+  let(:all_properties_yaml) { <<-EOF
+---
+flags:
+  flag1:
+    key: flag1
+    "on": true
+flagValues:
+  flag2: value2
+segments:
+  seg1:
+    key: seg1
+    include: ["user1"]  
+EOF
+  }
+
+  let(:bad_file_path) { "no-such-file" }
+
+  before do
+    @config = LaunchDarkly::Config.new
+    @store = @config.feature_store
+    @tmp_dir = Dir.mktmpdir
+  end
+
+  after do
+    FileUtils.remove_dir(@tmp_dir)
+  end
+
+  def make_temp_file(content)
+    # Note that we don't create our files in the default temp file directory, but rather in an empty directory
+    # that we made. That's because (depending on the platform) the temp file directory may contain huge numbers
+    # of files, which can make the file watcher perform poorly enough to break the tests.
+    file = Tempfile.new('flags', @tmp_dir)
+    IO.write(file, content)
+    file
+  end
+
+  def with_data_source(options)
+    factory = LaunchDarkly::FileDataSource.factory(options)
+    ds = factory.call('', @config)
+    begin
+      yield ds
+    ensure
+      ds.stop
+    end
+  end
+
+  it "doesn't load flags prior to start" do
+    file = make_temp_file('{"flagValues":{"key":"value"}}')
+    with_data_source({ paths: [ file.path ] }) do |ds|
+      expect(@store.initialized?).to eq(false)
+      expect(@store.all(LaunchDarkly::FEATURES)).to eq({})
+      expect(@store.all(LaunchDarkly::SEGMENTS)).to eq({})
+    end
+  end
+
+  it "loads flags on start - from JSON" do
+    file = make_temp_file(all_properties_json)
+    with_data_source({ paths: [ file.path ] }) do |ds|
+      ds.start
+      expect(@store.initialized?).to eq(true)
+      expect(@store.all(LaunchDarkly::FEATURES).keys).to eq(all_flag_keys)
+      expect(@store.all(LaunchDarkly::SEGMENTS).keys).to eq(all_segment_keys)
+    end
+  end
+
+  it "loads flags on start - from YAML" do
+    file = make_temp_file(all_properties_yaml)
+    with_data_source({ paths: [ file.path ] }) do |ds|
+      ds.start
+      expect(@store.initialized?).to eq(true)
+      expect(@store.all(LaunchDarkly::FEATURES).keys).to eq(all_flag_keys)
+      expect(@store.all(LaunchDarkly::SEGMENTS).keys).to eq(all_segment_keys)
+    end
+  end
+
+  it "sets start event and initialized on successful load" do
+    file = make_temp_file(all_properties_json)
+    with_data_source({ paths: [ file.path ] }) do |ds|
+      event = ds.start
+      expect(event.set?).to eq(true)
+      expect(ds.initialized?).to eq(true)
+    end
+  end
+
+  it "sets start event and does not set initialized on unsuccessful load" do
+    with_data_source({ paths: [ bad_file_path ] }) do |ds|
+      event = ds.start
+      expect(event.set?).to eq(true)
+      expect(ds.initialized?).to eq(false)
+    end
+  end
+
+  it "can load multiple files" do
+    file1 = make_temp_file(flag_only_json)
+    file2 = make_temp_file(segment_only_json)
+    with_data_source({ paths: [ file1.path, file2.path ] }) do |ds|
+      ds.start
+      expect(@store.initialized?).to eq(true)
+      expect(@store.all(LaunchDarkly::FEATURES).keys).to eq([ full_flag_1_key.to_sym ])
+      expect(@store.all(LaunchDarkly::SEGMENTS).keys).to eq([ full_segment_1_key.to_sym ])
+    end
+  end
+
+  it "does not allow duplicate keys" do
+    file1 = make_temp_file(flag_only_json)
+    file2 = make_temp_file(flag_only_json)
+    with_data_source({ paths: [ file1.path, file2.path ] }) do |ds|
+      ds.start
+      expect(@store.initialized?).to eq(false)
+      expect(@store.all(LaunchDarkly::FEATURES).keys).to eq([])
+    end
+  end
+
+  it "does not reload modified file if auto-update is off" do
+    file = make_temp_file(flag_only_json)
+
+    with_data_source({ paths: [ file.path ] }) do |ds|
+      event = ds.start
+      expect(event.set?).to eq(true)
+      expect(@store.all(LaunchDarkly::SEGMENTS).keys).to eq([])
+
+      IO.write(file, all_properties_json)
+      sleep(0.5)
+      expect(@store.all(LaunchDarkly::SEGMENTS).keys).to eq([])
+    end
+  end
+
+  def test_auto_reload(options)
+    file = make_temp_file(flag_only_json)
+    options[:paths] = [ file.path ]
+
+    with_data_source(options) do |ds|
+      event = ds.start
+      expect(event.set?).to eq(true)
+      expect(@store.all(LaunchDarkly::SEGMENTS).keys).to eq([])
+      
+      sleep(1)
+      IO.write(file, all_properties_json)
+      
+      max_time = 10
+      ok = wait_for_condition(10) { @store.all(LaunchDarkly::SEGMENTS).keys == all_segment_keys }
+      expect(ok).to eq(true), "Waited #{max_time}s after modifying file and it did not reload"
+    end
+  end
+
+  it "reloads modified file if auto-update is on" do
+    test_auto_reload({ auto_update: true })
+  end
+
+  it "reloads modified file in polling mode" do
+    test_auto_reload({ auto_update: true, force_polling: true, poll_interval: 0.1 })
+  end
+
+  it "evaluates simplified flag with client as expected" do
+    file = make_temp_file(all_properties_json)
+    factory = LaunchDarkly::FileDataSource.factory({ paths: file.path })
+    config = LaunchDarkly::Config.new(send_events: false, update_processor_factory: factory)
+    client = LaunchDarkly::LDClient.new('sdkKey', config)
+
+    begin
+      value = client.variation(flag_value_1_key, { key: 'user' }, '')
+      expect(value).to eq(flag_value_1)
+    ensure
+      client.close
+    end
+  end
+
+  it "evaluates full flag with client as expected" do
+    file = make_temp_file(all_properties_json)
+    factory = LaunchDarkly::FileDataSource.factory({ paths: file.path })
+    config = LaunchDarkly::Config.new(send_events: false, update_processor_factory: factory)
+    client = LaunchDarkly::LDClient.new('sdkKey', config)
+
+    begin
+      value = client.variation(full_flag_1_key, { key: 'user' }, '')
+      expect(value).to eq(full_flag_1_value)
+    ensure
+      client.close
+    end
+  end
+  
+  def wait_for_condition(max_time)
+    deadline = Time.now + max_time
+    while Time.now < deadline
+      return true if yield
+      sleep(0.1)
+    end
+    false
+  end
+end

data/spec/polling_spec.rb

@@ -3,10 +3,17 @@ require 'ostruct'
 
 describe LaunchDarkly::PollingProcessor do
   subject { LaunchDarkly::PollingProcessor }
-  let(:store) { LaunchDarkly::InMemoryFeatureStore.new }
-  let(:config) { LaunchDarkly::Config.new(feature_store: store) }
   let(:requestor) { double() }
-  let(:processor) { subject.new(config, requestor) }
+
+  def with_processor(store)
+    config = LaunchDarkly::Config.new(feature_store: store)
+    processor = subject.new(config, requestor)
+    begin
+      yield processor
+    ensure
+      processor.stop
+    end
+  end
 
   describe 'successful request' do
     flag = { key: 'flagkey', version: 1 }
@@ -22,47 +29,60 @@ describe LaunchDarkly::PollingProcessor do
 
     it 'puts feature data in store' do
       allow(requestor).to receive(:request_all_data).and_return(all_data)
-      ready = processor.start
-      ready.wait
-      expect(store.get(LaunchDarkly::FEATURES, "flagkey")).to eq(flag)
-      expect(store.get(LaunchDarkly::SEGMENTS, "segkey")).to eq(segment)
+      store = LaunchDarkly::InMemoryFeatureStore.new
+      with_processor(store) do |processor|
+        ready = processor.start
+        ready.wait
+        expect(store.get(LaunchDarkly::FEATURES, "flagkey")).to eq(flag)
+        expect(store.get(LaunchDarkly::SEGMENTS, "segkey")).to eq(segment)
+      end
     end
 
     it 'sets initialized to true' do
       allow(requestor).to receive(:request_all_data).and_return(all_data)
-      ready = processor.start
-      ready.wait
-      expect(processor.initialized?).to be true
-      expect(store.initialized?).to be true
+      store = LaunchDarkly::InMemoryFeatureStore.new
+      with_processor(store) do |processor|
+        ready = processor.start
+        ready.wait
+        expect(processor.initialized?).to be true
+        expect(store.initialized?).to be true
+      end
     end
   end
 
   describe 'connection error' do
     it 'does not cause immediate failure, does not set initialized' do
       allow(requestor).to receive(:request_all_data).and_raise(StandardError.new("test error"))
-      ready = processor.start
-      finished = ready.wait(0.2)
-      expect(finished).to be false
-      expect(processor.initialized?).to be false
-      expect(store.initialized?).to be false
+      store = LaunchDarkly::InMemoryFeatureStore.new
+      with_processor(store) do |processor|
+        ready = processor.start
+        finished = ready.wait(0.2)
+        expect(finished).to be false
+        expect(processor.initialized?).to be false
+        expect(store.initialized?).to be false
+      end
     end
   end
 
   describe 'HTTP errors' do
     def verify_unrecoverable_http_error(status)
       allow(requestor).to receive(:request_all_data).and_raise(LaunchDarkly::UnexpectedResponseError.new(status))
-      ready = processor.start
-      finished = ready.wait(0.2)
-      expect(finished).to be true
-      expect(processor.initialized?).to be false
+      with_processor(LaunchDarkly::InMemoryFeatureStore.new) do |processor|
+        ready = processor.start
+        finished = ready.wait(0.2)
+        expect(finished).to be true
+        expect(processor.initialized?).to be false
+      end
     end
 
     def verify_recoverable_http_error(status)
       allow(requestor).to receive(:request_all_data).and_raise(LaunchDarkly::UnexpectedResponseError.new(status))
-      ready = processor.start
-      finished = ready.wait(0.2)
-      expect(finished).to be false
-      expect(processor.initialized?).to be false
+      with_processor(LaunchDarkly::InMemoryFeatureStore.new) do |processor|
+        ready = processor.start
+        finished = ready.wait(0.2)
+        expect(finished).to be false
+        expect(processor.initialized?).to be false
+      end
     end
 
     it 'stops immediately for error 401' do
@@ -85,5 +105,16 @@ describe LaunchDarkly::PollingProcessor do
       verify_recoverable_http_error(503)
     end
   end
-end
 
+  describe 'stop' do
+    it 'stops promptly rather than continuing to wait for poll interval' do
+      with_processor(LaunchDarkly::InMemoryFeatureStore.new) do |processor|
+        sleep(1)  # somewhat arbitrary, but should ensure that it has started polling
+        start_time = Time.now
+        processor.stop
+        end_time = Time.now
+        expect(end_time - start_time).to be <(LaunchDarkly::Config.default_poll_interval - 5)
+      end
+    end
+  end
+end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: ldclient-rb
 version: !ruby/object:Gem::Version
-  version: 5.3.0
+  version: 5.4.1
 platform: ruby
 authors:
 - LaunchDarkly
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2018-10-24 00:00:00.000000000 Z
+date: 2018-11-05 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -122,6 +122,20 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: 0.9.1
+- !ruby/object:Gem::Dependency
+  name: listen
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
 - !ruby/object:Gem::Dependency
   name: json
   requirement: !ruby/object:Gem::Requirement
@@ -310,6 +324,7 @@ files:
 - lib/ldclient-rb/event_summarizer.rb
 - lib/ldclient-rb/events.rb
 - lib/ldclient-rb/expiring_cache.rb
+- lib/ldclient-rb/file_data_source.rb
 - lib/ldclient-rb/flags_state.rb
 - lib/ldclient-rb/in_memory_store.rb
 - lib/ldclient-rb/ldclient.rb
@@ -336,6 +351,7 @@ files:
 - spec/events_spec.rb
 - spec/expiring_cache_spec.rb
 - spec/feature_store_spec_base.rb
+- spec/file_data_source_spec.rb
 - spec/fixtures/feature.json
 - spec/fixtures/feature1.json
 - spec/fixtures/numeric_key_user.json
@@ -391,6 +407,7 @@ test_files:
 - spec/events_spec.rb
 - spec/expiring_cache_spec.rb
 - spec/feature_store_spec_base.rb
+- spec/file_data_source_spec.rb
 - spec/fixtures/feature.json
 - spec/fixtures/feature1.json
 - spec/fixtures/numeric_key_user.json