ldclient-rb 5.5.2 → 5.5.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 7d93c2f80940a876df8208c9ab53de33b9489cb1
-  data.tar.gz: f79f9ba1ac7e7716f14d20f8a6a83d5d8027c840
+  metadata.gz: 8e5398b81dc216177803939d535b130edbb0361a
+  data.tar.gz: 4c50f29da29da753db0a36064c29a22191960808
 SHA512:
-  metadata.gz: 4151fd38371a01e1856c591d50a5f13e5818488266247e73f25a13273982e06bb47f35ca09cec46cb1389737acaf39818325fcd1a56138a0e5fcd66d4a30f8f2
-  data.tar.gz: acec0d1362df8a46fa7077423202462866bec5af12e7d86f27c1b9d18c76ccc6c4d89572caa44258c57df4ac5bc513ff19d1347cdd8598f29c85f90b6d0896c0
+  metadata.gz: 894d4f29200b6a5df70608942f15223a9b9d5bdeb426913f3afe9feb7d23b02b2ef544874ba7c39570b3f8e8c098caafab638ff9b779b9aec69ca444d1115b62
+  data.tar.gz: 41c088debbc36d16b7518b20af0ddc4c9b488e0da16b9e465d573ab6e715f00612fb53ee4fe492692cf0d065aa16c3e85ba2d17314c1c326110415ac4667b310

data/CHANGELOG.md

@@ -2,6 +2,15 @@
 
 All notable changes to the LaunchDarkly Ruby SDK will be documented in this file. This project adheres to [Semantic Versioning](http://semver.org).
 
+## [5.5.3] - 2019-02-13
+### Changed:
+- The SDK previously used the `faraday` and `net-http-persistent` gems for all HTTP requests other than streaming connections. Since `faraday` lacks a stable version and has a known issue with character encoding, and `net-http-persistent` is no longer maintained, these have both been removed. This should not affect any SDK functionality.
+
+### Fixed:
+- The SDK was not usable in Windows because of `net-http-persistent`. That gem has been removed.
+- When running in Windows, the event-processing thread threw a `RangeError` due to a difference in the Windows implementation of `concurrent-ruby`. This has been fixed.
+- Windows incompatibilities were undetected before because we were not running a Windows CI job. We are now testing on Windows with Ruby 2.5.
+
 ## [5.5.2] - 2019-01-18
 ### Fixed:
 - Like 5.5.1, this release contains only documentation fixes. Implementation classes that are not part of the supported API are now hidden from the [generated documentation](https://www.rubydoc.info/gems/ldclient-rb).

data/Gemfile.lock

@@ -1,13 +1,10 @@
 PATH
   remote: .
   specs:
-    ldclient-rb (5.4.3)
+    ldclient-rb (5.5.2)
       concurrent-ruby (~> 1.0)
-      faraday (>= 0.9, < 2)
-      faraday-http-cache (>= 1.3.0, < 3)
       json (>= 1.8, < 3)
       ld-eventsource (~> 1.0)
-      net-http-persistent (>= 2.9, < 4.0)
       semantic (~> 1.6)
 
 GEM
@@ -35,11 +32,10 @@ GEM
     docile (1.1.5)
     faraday (0.15.4)
       multipart-post (>= 1.2, < 3)
-    faraday-http-cache (2.0.0)
-      faraday (~> 0.8)
     ffi (1.9.25)
     ffi (1.9.25-java)
-    hitimes (1.3.0)
+    hitimes (1.3.1)
+    hitimes (1.3.1-java)
     http_tools (0.4.5)
     jmespath (1.4.0)
     json (1.8.6)
@@ -53,8 +49,6 @@ GEM
       rb-inotify (~> 0.9, >= 0.9.7)
       ruby_dep (~> 1.2)
     multipart-post (2.0.0)
-    net-http-persistent (3.0.0)
-      connection_pool (~> 2.2)
     rake (10.5.0)
     rb-fsevent (0.10.3)
     rb-inotify (0.9.10)

data/README.md

@@ -17,19 +17,19 @@ Quick setup
 
 1. Install the Ruby SDK with `gem`
 
-    ```shell
+```shell
 gem install ldclient-rb
 ```
 
 2. Require the LaunchDarkly client:
 
-    ```ruby
+```ruby
 require 'ldclient-rb'
 ```
 
 3. Create a new LDClient with your SDK key:
 
-    ```ruby
+```ruby
 client = LaunchDarkly::LDClient.new("your_sdk_key")
 ```
 
@@ -39,42 +39,42 @@ client = LaunchDarkly::LDClient.new("your_sdk_key")
 
 2. Initialize the launchdarkly client in `config/initializers/launchdarkly.rb`:
 
-    ```ruby
+```ruby
 Rails.configuration.ld_client = LaunchDarkly::LDClient.new("your_sdk_key")
 ```
 
 3.  You may want to include a function in your ApplicationController
 
-    ```ruby
-    def launchdarkly_settings
-      if current_user.present?
-        {
-          key: current_user.id,
-          anonymous: false,
-          email: current_user.email,
-          custom: { groups: current_user.groups.pluck(:name) },
-          # Any other fields you may have
-          # e.g. lastName: current_user.last_name,
-        }
-      else
-        if Rails::VERSION::MAJOR <= 3
-          hash_key = request.session_options[:id]
-        else
-          hash_key = session.id
-        end
-        # session ids should be private to prevent session hijacking
-        hash_key = Digest::SHA256.base64digest hash_key
-        {
-          key: hash_key,
-          anonymous: true,
-        }
-      end
+```ruby
+def launchdarkly_settings
+  if current_user.present?
+    {
+      key: current_user.id,
+      anonymous: false,
+      email: current_user.email,
+      custom: { groups: current_user.groups.pluck(:name) },
+      # Any other fields you may have
+      # e.g. lastName: current_user.last_name,
+    }
+  else
+    if Rails::VERSION::MAJOR <= 3
+      hash_key = request.session_options[:id]
+    else
+      hash_key = session.id
     end
+    # session ids should be private to prevent session hijacking
+    hash_key = Digest::SHA256.base64digest hash_key
+    {
+      key: hash_key,
+      anonymous: true,
+    }
+  end
+end
 ```
 
 4. In your controllers, access the client using
 
-    ```ruby
+```ruby
 Rails.application.config.ld_client.variation('your.flag.key', launchdarkly_settings, false)
 ```
 

data/azure-pipelines.yml

@@ -0,0 +1,51 @@
+jobs:
+  - job: build
+    pool:
+      vmImage: 'vs2017-win2016'
+    steps:
+      - task: PowerShell@2
+        displayName: 'Setup Dynamo'
+        inputs:
+          targetType: inline
+          workingDirectory: $(System.DefaultWorkingDirectory)
+          script: |
+            iwr -outf dynamo.zip https://s3-us-west-2.amazonaws.com/dynamodb-local/dynamodb_local_latest.zip
+            mkdir dynamo
+            Expand-Archive -Path dynamo.zip -DestinationPath dynamo
+            cd dynamo
+            javaw -D"java.library.path=./DynamoDBLocal_lib" -jar DynamoDBLocal.jar
+      - task: PowerShell@2
+        displayName: 'Setup Consul'
+        inputs:
+          targetType: inline
+          workingDirectory: $(System.DefaultWorkingDirectory)
+          script: |
+            iwr -outf consul.zip https://releases.hashicorp.com/consul/1.4.2/consul_1.4.2_windows_amd64.zip
+            mkdir consul
+            Expand-Archive -Path consul.zip -DestinationPath consul
+            cd consul
+            sc.exe create "Consul" binPath="$(System.DefaultWorkingDirectory)/consul/consul.exe agent -dev"
+            sc.exe start "Consul"
+      - task: PowerShell@2
+        displayName: 'Setup Redis'
+        inputs:
+          targetType: inline
+          workingDirectory: $(System.DefaultWorkingDirectory)
+          script: |
+            iwr -outf redis.zip https://github.com/MicrosoftArchive/redis/releases/download/win-3.0.504/Redis-x64-3.0.504.zip
+            mkdir redis
+            Expand-Archive -Path redis.zip -DestinationPath redis
+            cd redis
+            ./redis-server --service-install
+            ./redis-server --service-start
+      - task: PowerShell@2
+        displayName: 'Setup SDK and Test'
+        inputs:
+          targetType: inline
+          workingDirectory: $(System.DefaultWorkingDirectory)
+          script: |
+            ruby -v
+            gem install bundler -v 1.17.3
+            bundle install
+            mkdir rspec
+            bundle exec rspec --format progress --format RspecJunitFormatter -o ./rspec/rspec.xml spec

data/ldclient-rb.gemspec

@@ -34,10 +34,7 @@ Gem::Specification.new do |spec|
   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"]
-  spec.add_runtime_dependency "faraday-http-cache", [">= 1.3.0", "< 3"]
   spec.add_runtime_dependency "semantic", "~> 1.6"
-  spec.add_runtime_dependency "net-http-persistent", [">= 2.9", "< 4.0"]
   spec.add_runtime_dependency "concurrent-ruby", "~> 1.0"
   spec.add_runtime_dependency "ld-eventsource", '~> 1.0'
 end

data/lib/ldclient-rb/cache_store.rb

@@ -2,11 +2,9 @@ require "concurrent/map"
 
 module LaunchDarkly
   #
-  # A thread-safe in-memory store suitable for use with the Faraday caching HTTP client. Uses the
-  # concurrent-ruby gem's Map as the underlying cache.
+  # A thread-safe in-memory store that uses the same semantics that Faraday would expect, although we
+  # no longer use Faraday. This is used by Requestor, when we are not in a Rails environment.
   #
-  # @see https://github.com/plataformatec/faraday-http-cache
-  # @see https://github.com/ruby-concurrency
   # @private
   #
   class ThreadSafeMemoryStore

data/lib/ldclient-rb/config.rb

@@ -53,7 +53,6 @@ module LaunchDarkly
       @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] > Config.default_poll_interval ? 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
@@ -153,9 +152,10 @@ module LaunchDarkly
     attr_reader :capacity
 
     #
-    # A store for HTTP caching. This must support the semantics used by the
-    # [`faraday-http-cache`](https://github.com/plataformatec/faraday-http-cache) gem. Defaults
-    # to the Rails cache in a Rails environment, or a thread-safe in-memory store otherwise.
+    # A store for HTTP caching (used only in polling mode). This must support the semantics used by
+    # the [`faraday-http-cache`](https://github.com/plataformatec/faraday-http-cache) gem, although
+    # the SDK no longer uses Faraday. Defaults to the Rails cache in a Rails environment, or a
+    # thread-safe in-memory store otherwise.
     # @return [Object]
     #
     attr_reader :cache_store
@@ -184,12 +184,6 @@ module LaunchDarkly
     #
     attr_reader :feature_store
 
-    #
-    # The proxy configuration string.
-    # @return [String]
-    #
-    attr_reader :proxy
-
     #
     # True if all user attributes (other than the key) should be considered private. This means
     # that the attribute values will not be sent to LaunchDarkly in analytics events and will not
@@ -336,14 +330,6 @@ module LaunchDarkly
       2
     end
 
-    #
-    # The default value for {#proxy}.
-    # @return [String] nil
-    #
-    def self.default_proxy
-      nil
-    end
-
     #
     # The default value for {#logger}.
     # @return [Logger] the Rails logger if in Rails, or a default Logger at WARN level otherwise

data/lib/ldclient-rb/events.rb

@@ -3,7 +3,6 @@ require "concurrent/atomics"
 require "concurrent/executors"
 require "thread"
 require "time"
-require "faraday"
 
 module LaunchDarkly
   MAX_FLUSH_WORKERS = 5
@@ -115,11 +114,17 @@ module LaunchDarkly
     def initialize(queue, sdk_key, config, client)
       @sdk_key = sdk_key
       @config = config
-      @client = client ? client : Faraday.new
+
+      if client
+        @client = client
+      else
+        @client = Util.new_http_client(@config.events_uri, @config)
+      end
+
       @user_keys = SimpleLRUCacheSet.new(config.user_keys_capacity)
       @formatter = EventOutputFormatter.new(config)
       @disabled = Concurrent::AtomicBoolean.new(false)
-      @last_known_past_time = Concurrent::AtomicFixnum.new(0)
+      @last_known_past_time = Concurrent::AtomicReference.new(0)
 
       buffer = EventBuffer.new(config.capacity, config.logger)
       flush_workers = NonBlockingThreadPool.new(MAX_FLUSH_WORKERS)
@@ -162,7 +167,10 @@ module LaunchDarkly
     def do_shutdown(flush_workers)
       flush_workers.shutdown
       flush_workers.wait_for_termination
-      # There seems to be no such thing as "close" in Faraday: https://github.com/lostisland/faraday/issues/241
+      begin
+        @client.finish
+      rescue
+      end
     end
 
     def synchronize_for_testing(flush_workers)
@@ -246,16 +254,17 @@ module LaunchDarkly
     end
 
     def handle_response(res)
-      if res.status >= 400
-        message = Util.http_error_message(res.status, "event delivery", "some events were dropped")
+      status = res.code.to_i
+      if status >= 400
+        message = Util.http_error_message(status, "event delivery", "some events were dropped")
         @config.logger.error { "[LDClient] #{message}" }
-        if !Util.http_error_recoverable?(res.status)
+        if !Util.http_error_recoverable?(status)
           @disabled.value = true
         end
       else
-        if !res.headers.nil? && res.headers.has_key?("Date")
+        if !res["date"].nil?
           begin
-            res_time = (Time.httpdate(res.headers["Date"]).to_f * 1000).to_i
+            res_time = (Time.httpdate(res["date"]).to_f * 1000).to_i
             @last_known_past_time.value = res_time
           rescue ArgumentError
           end
@@ -316,22 +325,24 @@ module LaunchDarkly
           sleep(1)
         end
         begin
+          client.start if !client.started?
           config.logger.debug { "[LDClient] sending #{events_out.length} events: #{body}" }
-          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.headers["X-LaunchDarkly-Event-Schema"] = CURRENT_SCHEMA_VERSION.to_s
-            req.body = body
-            req.options.timeout = config.read_timeout
-            req.options.open_timeout = config.connect_timeout
-          end
+          uri = URI(config.events_uri + "/bulk")
+          req = Net::HTTP::Post.new(uri)
+          req.content_type = "application/json"
+          req.body = body
+          req["Authorization"] = sdk_key
+          req["User-Agent"] = "RubyClient/" + LaunchDarkly::VERSION
+          req["X-LaunchDarkly-Event-Schema"] = CURRENT_SCHEMA_VERSION.to_s
+          req["Connection"] = "keep-alive"
+          res = client.request(req)
         rescue StandardError => exn
           config.logger.warn { "[LDClient] Error flushing events: #{exn.inspect}." }
           next
         end
-        if res.status < 200 || res.status >= 300
-          if Util.http_error_recoverable?(res.status)
+        status = res.code.to_i
+        if status < 200 || status >= 300
+          if Util.http_error_recoverable?(status)
             next
           end
         end

data/lib/ldclient-rb/polling.rb

@@ -26,7 +26,7 @@ module LaunchDarkly
 
     def stop
       if @stopped.make_true
-        if @worker && @worker.alive?
+        if @worker && @worker.alive? && @worker != Thread.current
           @worker.run  # causes the thread to wake up if it's currently in a sleep
           @worker.join
         end
@@ -63,8 +63,7 @@ module LaunchDarkly
               stop
             end
           rescue StandardError => exn
-            @config.logger.error { "[LDClient] Exception while polling: #{exn.inspect}" }
-            # TODO: log_exception(__method__.to_s, exn)
+            Util.log_exception(@config.logger, "Exception while polling", exn)
           end
           delta = @config.poll_interval - (Time.now - started_at)
           if delta > 0

data/lib/ldclient-rb/requestor.rb

@@ -1,12 +1,13 @@
+require "concurrent/atomics"
 require "json"
-require "net/http/persistent"
-require "faraday/http_cache"
+require "uri"
 
 module LaunchDarkly
   # @private
   class UnexpectedResponseError < StandardError
     def initialize(status)
       @status = status
+      super("HTTP error #{status}")
     end
 
     def status
@@ -16,14 +17,13 @@ module LaunchDarkly
 
   # @private
   class Requestor
+    CacheEntry = Struct.new(:etag, :body)
+
     def initialize(sdk_key, config)
       @sdk_key = sdk_key
       @config = config
-      @client = Faraday.new do |builder|
-        builder.use :http_cache, store: @config.cache_store, serializer: Marshal
-        
-        builder.adapter :net_http_persistent
-      end
+      @client = Util.new_http_client(@config.base_uri, @config)
+      @cache = @config.cache_store
     end
 
     def request_flag(key)
@@ -38,27 +38,64 @@ module LaunchDarkly
       make_request("/sdk/latest-all")
     end
     
-    def make_request(path)
-      uri = @config.base_uri + path
-      res = @client.get (uri) do |req|
-        req.headers["Authorization"] = @sdk_key
-        req.headers["User-Agent"] = "RubyClient/" + LaunchDarkly::VERSION
-        req.options.timeout = @config.read_timeout
-        req.options.open_timeout = @config.connect_timeout
-        if @config.proxy
-          req.options.proxy = Faraday::ProxyOptions.from @config.proxy
-        end
+    def stop
+      begin
+        @client.finish
+      rescue
       end
+    end
 
-      @config.logger.debug { "[LDClient] Got response from uri: #{uri}\n\tstatus code: #{res.status}\n\theaders: #{res.headers}\n\tbody: #{res.body}" }
+    private
 
-      if res.status < 200 || res.status >= 300
-        raise UnexpectedResponseError.new(res.status)
+    def make_request(path)
+      @client.start if !@client.started?
+      uri = URI(@config.base_uri + path)
+      req = Net::HTTP::Get.new(uri)
+      req["Authorization"] = @sdk_key
+      req["User-Agent"] = "RubyClient/" + LaunchDarkly::VERSION
+      req["Connection"] = "keep-alive"
+      cached = @cache.read(uri)
+      if !cached.nil?
+        req["If-None-Match"] = cached.etag
       end
+      res = @client.request(req)
+      status = res.code.to_i
+      @config.logger.debug { "[LDClient] Got response from uri: #{uri}\n\tstatus code: #{status}\n\theaders: #{res.to_hash}\n\tbody: #{res.body}" }
 
-      JSON.parse(res.body, symbolize_names: true)
+      if status == 304 && !cached.nil?
+        body = cached.body
+      else
+        @cache.delete(uri)
+        if status < 200 || status >= 300
+          raise UnexpectedResponseError.new(status)
+        end
+        body = fix_encoding(res.body, res["content-type"])
+        etag = res["etag"]
+        @cache.write(uri, CacheEntry.new(etag, body)) if !etag.nil?
+      end
+      JSON.parse(body, symbolize_names: true)
+    end
+
+    def fix_encoding(body, content_type)
+      return body if content_type.nil?
+      media_type, charset = parse_content_type(content_type)
+      return body if charset.nil?
+      body.force_encoding(Encoding::find(charset)).encode(Encoding::UTF_8)
     end
 
-    private :make_request
+    def parse_content_type(value)
+      return [nil, nil] if value.nil? || value == ''
+      parts = value.split(/; */)
+      return [value, nil] if parts.count < 2
+      charset = nil
+      parts.each do |part|
+        fields = part.split('=')
+        if fields.count >= 2 && fields[0] == 'charset'
+          charset = fields[1]
+          break
+        end
+      end
+      return [parts[0], charset]
+    end
   end
 end

data/lib/ldclient-rb/stream.rb

@@ -50,7 +50,6 @@ module LaunchDarkly
       }
       opts = {
         headers: headers,
-        proxy: @config.proxy,
         read_timeout: READ_TIMEOUT_SECONDS,
         logger: @config.logger
       }

data/lib/ldclient-rb/util.rb

@@ -1,7 +1,17 @@
+require "uri"
 
 module LaunchDarkly
   # @private
   module Util
+    def self.new_http_client(uri_s, config)
+      uri = URI(uri_s)
+      client = Net::HTTP.new(uri.hostname, uri.port)
+      client.use_ssl = true if uri.scheme == "https"
+      client.open_timeout = config.connect_timeout
+      client.read_timeout = config.read_timeout
+      client
+    end
+
     def self.log_exception(logger, message, exc)
       logger.error { "[LDClient] #{message}: #{exc.inspect}" }
       logger.debug { "[LDClient] Exception trace: #{exc.backtrace}" }

data/lib/ldclient-rb/version.rb

@@ -1,3 +1,3 @@
 module LaunchDarkly
-  VERSION = "5.5.2"
+  VERSION = "5.5.3"
 end

data/spec/events_spec.rb

@@ -1,5 +1,5 @@
+require "http_util"
 require "spec_helper"
-require "faraday"
 require "time"
 
 describe LaunchDarkly::EventProcessor do
@@ -348,7 +348,7 @@ describe LaunchDarkly::EventProcessor do
     @ep.flush
     @ep.wait_until_inactive
     
-    expect(hc.get_request.headers["Authorization"]).to eq "sdk_key"
+    expect(hc.get_request["authorization"]).to eq "sdk_key"
   end
 
   def verify_unrecoverable_http_error(status)
@@ -414,7 +414,7 @@ describe LaunchDarkly::EventProcessor do
     e = { kind: "identify", user: user }
     @ep.add_event(e)
 
-    hc.set_exception(Faraday::Error::ConnectionFailed.new("fail"))
+    hc.set_exception(IOError.new("deliberate error"))
     @ep.flush
     @ep.wait_until_inactive
 
@@ -423,6 +423,46 @@ describe LaunchDarkly::EventProcessor do
     expect(hc.get_request).to be_nil  # no 3rd request
   end
 
+  it "makes actual HTTP request with correct headers" do
+    e = { kind: "identify", key: user[:key], user: user }
+    with_server do |server|
+      server.setup_ok_response("/bulk", "")
+
+      @ep = subject.new("sdk_key", LaunchDarkly::Config.new(events_uri: server.base_uri.to_s))
+      @ep.add_event(e)
+      @ep.flush
+
+      req = server.await_request
+      expect(req.header).to include({
+        "authorization" => [ "sdk_key" ],
+        "content-type" => [ "application/json" ],
+        "user-agent" => [ "RubyClient/" + LaunchDarkly::VERSION ],
+        "x-launchdarkly-event-schema" => [ "3" ]
+      })
+    end
+  end
+
+  it "can use a proxy server" do
+    e = { kind: "identify", key: user[:key], user: user }
+    with_server do |server|
+      server.setup_ok_response("/bulk", "")
+
+      with_server(StubProxyServer.new) do |proxy|
+        begin
+          ENV["http_proxy"] = proxy.base_uri.to_s
+          @ep = subject.new("sdk_key", LaunchDarkly::Config.new(events_uri: server.base_uri.to_s))
+          @ep.add_event(e)
+          @ep.flush
+
+          req = server.await_request
+          expect(req["content-type"]).to eq("application/json")
+        ensure
+          ENV["http_proxy"] = nil
+        end
+      end
+    end
+  end
+
   def index_event(e, user)
     {
       kind: "index",
@@ -496,38 +536,42 @@ describe LaunchDarkly::EventProcessor do
       @status = 200
     end
 
-    def post(uri)
-      req = Faraday::Request.create("POST")
-      req.headers = {}
-      req.options = Faraday::RequestOptions.new
-      yield req
+    def request(req)
       @requests.push(req)
       if @exception
         raise @exception
       else
-        resp = Faraday::Response.new
         headers = {}
         if @server_time
           headers["Date"] = @server_time.httpdate
         end
-        resp.finish({
-          status: @status ? @status : 200,
-          response_headers: headers
-        })
-        resp
+        FakeResponse.new(@status ? @status : 200, headers)
       end
     end
 
+    def start
+    end
+
+    def started?
+      false
+    end
+
+    def finish
+    end
+
     def get_request
       @requests.shift
     end
   end
 
   class FakeResponse
-    def initialize(status)
-      @status = status
-    end
+    include Net::HTTPHeader
 
-    attr_reader :status
+    attr_reader :code
+
+    def initialize(status, headers)
+      @code = status.to_s
+      initialize_http_header(headers)
+    end
   end
 end

data/spec/file_data_source_spec.rb

@@ -74,7 +74,7 @@ flagValues:
 segments:
   seg1:
     key: seg1
-    include: ["user1"]  
+    include: ["user1"]
 EOF
   }
 
@@ -87,7 +87,7 @@ EOF
   end
 
   after do
-    FileUtils.remove_dir(@tmp_dir)
+    FileUtils.rm_rf(@tmp_dir)
   end
 
   def make_temp_file(content)
@@ -198,10 +198,10 @@ EOF
       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"
@@ -243,7 +243,7 @@ EOF
       client.close
     end
   end
-  
+
   def wait_for_condition(max_time)
     deadline = Time.now + max_time
     while Time.now < deadline

data/spec/http_util.rb

@@ -23,6 +23,7 @@ class StubHTTPServer
       retry
     end
     @requests = []
+    @requests_queue = Queue.new
   end
 
   def self.next_port
@@ -62,6 +63,11 @@ class StubHTTPServer
 
   def record_request(req, res)
     @requests.push(req)
+    @requests_queue << req
+  end
+
+  def await_request
+    @requests_queue.pop
   end
 end
 

data/spec/requestor_spec.rb

@@ -1,57 +1,212 @@
 require "http_util"
 require "spec_helper"
 
+$sdk_key = "secret"
+
 describe LaunchDarkly::Requestor do
-  describe ".request_all_flags" do
-    describe "with a proxy" do
-      it "converts the proxy option" do
-        content = '{"flags": {"flagkey": {"key": "flagkey"}}}'
-        with_server do |server|
-          server.setup_ok_response("/sdk/latest-all", content, "application/json", { "etag" => "x" })
-          with_server(StubProxyServer.new) do |proxy|
-            config = LaunchDarkly::Config.new(base_uri: server.base_uri.to_s, proxy: proxy.base_uri.to_s)
-            r = LaunchDarkly::Requestor.new("sdk-key", config)
-            result = r.request_all_data
-            expect(result).to eq(JSON.parse(content, symbolize_names: true))
-          end
-        end
-      end
-    end
-    describe "without a proxy" do
-      it "sends headers" do
-        content = '{"flags": {}}'
-        sdk_key = 'sdk-key'
-        with_server do |server|
-          server.setup_ok_response("/sdk/latest-all", content, "application/json", { "etag" => "x" })
-          r = LaunchDarkly::Requestor.new(sdk_key, LaunchDarkly::Config.new({ base_uri: server.base_uri.to_s }))
-          r.request_all_data
-          expect(server.requests.length).to eq 1
-          req = server.requests[0]
-          expect(req.header['authorization']).to eq [sdk_key]
-          expect(req.header['user-agent']).to eq ["RubyClient/" + LaunchDarkly::VERSION]
-        end
-      end
-
-      it "receives data" do
-        content = '{"flags": {"flagkey": {"key": "flagkey"}}}'
-        with_server do |server|
-          server.setup_ok_response("/sdk/latest-all", content, "application/json", { "etag" => "x" })
-          r = LaunchDarkly::Requestor.new("sdk-key", LaunchDarkly::Config.new({ base_uri: server.base_uri.to_s }))
-          result = r.request_all_data
-          expect(result).to eq(JSON.parse(content, symbolize_names: true))
-        end
-      end
-
-      it "handles Unicode content" do
-        content = '{"flags": {"flagkey": {"key": "flagkey", "variations": ["blue", "grėeń"]}}}'
-        with_server do |server|
-          server.setup_ok_response("/sdk/latest-all", content, "application/json", { "etag" => "x" })
-          # Note that the ETag header here is important because without it, the HTTP cache will not be used,
-          # and the cache is what required a fix to handle Unicode properly. See:
-          #   https://github.com/launchdarkly/ruby-client/issues/90
-          r = LaunchDarkly::Requestor.new("sdk-key", LaunchDarkly::Config.new({ base_uri: server.base_uri.to_s }))
-          result = r.request_all_data
-          expect(result).to eq(JSON.parse(content, symbolize_names: true))
+  def with_requestor(base_uri)
+    r = LaunchDarkly::Requestor.new($sdk_key, LaunchDarkly::Config.new(base_uri: base_uri))
+    yield r
+    r.stop
+  end
+
+  describe "request_all_flags" do
+    it "uses expected URI and headers" do
+      with_server do |server|
+        with_requestor(server.base_uri.to_s) do |requestor|
+          server.setup_ok_response("/", "{}")
+          requestor.request_all_data()
+          expect(server.requests.count).to eq 1
+          expect(server.requests[0].unparsed_uri).to eq "/sdk/latest-all"
+          expect(server.requests[0].header).to include({
+            "authorization" => [ $sdk_key ],
+            "user-agent" => [ "RubyClient/" + LaunchDarkly::VERSION ]
+          })
+        end
+      end
+    end
+
+    it "parses response" do
+      expected_data = { flags: { x: { key: "x" } } }
+      with_server do |server|
+        with_requestor(server.base_uri.to_s) do |requestor|
+          server.setup_ok_response("/", expected_data.to_json)
+          data = requestor.request_all_data()
+          expect(data).to eq expected_data
+        end
+      end
+    end
+
+    it "sends etag from previous response" do
+      etag = "xyz"
+      with_server do |server|
+        with_requestor(server.base_uri.to_s) do |requestor|
+          server.setup_response("/") do |req, res|
+            res.status = 200
+            res.body = "{}"
+            res["ETag"] = etag
+          end
+          requestor.request_all_data()
+          expect(server.requests.count).to eq 1
+
+          requestor.request_all_data()
+          expect(server.requests.count).to eq 2
+          expect(server.requests[1].header).to include({ "if-none-match" => [ etag ] })
+        end
+      end
+    end
+
+    it "can reuse cached data" do
+      etag = "xyz"
+      expected_data = { flags: { x: { key: "x" } } }
+      with_server do |server|
+        with_requestor(server.base_uri.to_s) do |requestor|
+          server.setup_response("/") do |req, res|
+            res.status = 200
+            res.body = expected_data.to_json
+            res["ETag"] = etag
+          end
+          requestor.request_all_data()
+          expect(server.requests.count).to eq 1
+
+          server.setup_response("/") do |req, res|
+            res.status = 304
+          end
+          data = requestor.request_all_data()
+          expect(server.requests.count).to eq 2
+          expect(server.requests[1].header).to include({ "if-none-match" => [ etag ] })
+          expect(data).to eq expected_data
+        end
+      end
+    end
+
+    it "replaces cached data with new data" do
+      etag1 = "abc"
+      etag2 = "xyz"
+      expected_data1 = { flags: { x: { key: "x" } } }
+      expected_data2 = { flags: { y: { key: "y" } } }
+      with_server do |server|
+        with_requestor(server.base_uri.to_s) do |requestor|
+          server.setup_response("/") do |req, res|
+            res.status = 200
+            res.body = expected_data1.to_json
+            res["ETag"] = etag1
+          end
+          data = requestor.request_all_data()
+          expect(data).to eq expected_data1
+          expect(server.requests.count).to eq 1
+
+          server.setup_response("/") do |req, res|
+            res.status = 304
+          end
+          data = requestor.request_all_data()
+          expect(data).to eq expected_data1
+          expect(server.requests.count).to eq 2
+          expect(server.requests[1].header).to include({ "if-none-match" => [ etag1 ] })
+
+          server.setup_response("/") do |req, res|
+            res.status = 200
+            res.body = expected_data2.to_json
+            res["ETag"] = etag2
+          end
+          data = requestor.request_all_data()
+          expect(data).to eq expected_data2
+          expect(server.requests.count).to eq 3
+          expect(server.requests[2].header).to include({ "if-none-match" => [ etag1 ] })
+
+          server.setup_response("/") do |req, res|
+            res.status = 304
+          end
+          data = requestor.request_all_data()
+          expect(data).to eq expected_data2
+          expect(server.requests.count).to eq 4
+          expect(server.requests[3].header).to include({ "if-none-match" => [ etag2 ] })
+        end
+      end
+    end
+
+    it "uses UTF-8 encoding by default" do
+      content = '{"flags": {"flagkey": {"key": "flagkey", "variations": ["blue", "grėeń"]}}}'
+      with_server do |server|
+        server.setup_ok_response("/sdk/latest-all", content, "application/json")
+        with_requestor(server.base_uri.to_s) do |requestor|
+          data = requestor.request_all_data
+          expect(data).to eq(JSON.parse(content, symbolize_names: true))
+        end
+      end
+    end
+
+    it "detects other encodings from Content-Type" do
+      content = '{"flags": {"flagkey": {"key": "flagkey", "variations": ["proszę", "dziękuję"]}}}'
+      with_server do |server|
+        server.setup_ok_response("/sdk/latest-all", content.encode(Encoding::ISO_8859_2),
+          "text/plain; charset=ISO-8859-2")
+        with_requestor(server.base_uri.to_s) do |requestor|
+          data = requestor.request_all_data
+          expect(data).to eq(JSON.parse(content, symbolize_names: true))
+        end
+      end
+    end
+
+    it "throws exception for error status" do
+      with_server do |server|
+        with_requestor(server.base_uri.to_s) do |requestor|
+          server.setup_response("/") do |req, res|
+            res.status = 400
+          end
+          expect { requestor.request_all_data() }.to raise_error(LaunchDarkly::UnexpectedResponseError)
+        end
+      end
+    end
+
+    it "can use a proxy server" do
+      content = '{"flags": {"flagkey": {"key": "flagkey"}}}'
+      with_server do |server|
+        server.setup_ok_response("/sdk/latest-all", content, "application/json", { "etag" => "x" })
+        with_server(StubProxyServer.new) do |proxy|
+          begin
+            ENV["http_proxy"] = proxy.base_uri.to_s
+            with_requestor(server.base_uri.to_s) do |requestor|
+              data = requestor.request_all_data
+              expect(data).to eq(JSON.parse(content, symbolize_names: true))
+            end
+          ensure
+            ENV["http_proxy"] = nil
+          end
+        end
+      end
+    end
+  end
+
+  describe "request_flag" do
+    it "uses expected URI and headers" do
+      with_server do |server|
+        with_requestor(server.base_uri.to_s) do |requestor|
+          server.setup_ok_response("/", "{}")
+          requestor.request_flag("key")
+          expect(server.requests.count).to eq 1
+          expect(server.requests[0].unparsed_uri).to eq "/sdk/latest-flags/key"
+          expect(server.requests[0].header).to include({
+            "authorization" => [ $sdk_key ],
+            "user-agent" => [ "RubyClient/" + LaunchDarkly::VERSION ]
+          })
+        end
+      end
+    end
+  end
+
+  describe "request_segment" do
+    it "uses expected URI and headers" do
+      with_server do |server|
+        with_requestor(server.base_uri.to_s) do |requestor|
+          server.setup_ok_response("/", "{}")
+          requestor.request_segment("key")
+          expect(server.requests.count).to eq 1
+          expect(server.requests[0].unparsed_uri).to eq "/sdk/latest-segments/key"
+          expect(server.requests[0].header).to include({
+            "authorization" => [ $sdk_key ],
+            "user-agent" => [ "RubyClient/" + LaunchDarkly::VERSION ]
+          })
         end
       end
     end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: ldclient-rb
 version: !ruby/object:Gem::Version
-  version: 5.5.2
+  version: 5.5.3
 platform: ruby
 authors:
 - LaunchDarkly
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2019-01-18 00:00:00.000000000 Z
+date: 2019-02-14 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: aws-sdk-dynamodb
@@ -184,46 +184,6 @@ dependencies:
     - - "<"
       - !ruby/object:Gem::Version
         version: '3'
-- !ruby/object:Gem::Dependency
-  name: faraday
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '0.9'
-    - - "<"
-      - !ruby/object:Gem::Version
-        version: '2'
-  type: :runtime
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '0.9'
-    - - "<"
-      - !ruby/object:Gem::Version
-        version: '2'
-- !ruby/object:Gem::Dependency
-  name: faraday-http-cache
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: 1.3.0
-    - - "<"
-      - !ruby/object:Gem::Version
-        version: '3'
-  type: :runtime
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: 1.3.0
-    - - "<"
-      - !ruby/object:Gem::Version
-        version: '3'
 - !ruby/object:Gem::Dependency
   name: semantic
   requirement: !ruby/object:Gem::Requirement
@@ -238,26 +198,6 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '1.6'
-- !ruby/object:Gem::Dependency
-  name: net-http-persistent
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '2.9'
-    - - "<"
-      - !ruby/object:Gem::Version
-        version: '4.0'
-  type: :runtime
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '2.9'
-    - - "<"
-      - !ruby/object:Gem::Version
-        version: '4.0'
 - !ruby/object:Gem::Dependency
   name: concurrent-ruby
   requirement: !ruby/object:Gem::Requirement
@@ -309,6 +249,7 @@ files:
 - LICENSE.txt
 - README.md
 - Rakefile
+- azure-pipelines.yml
 - ext/mkrf_conf.rb
 - ldclient-rb.gemspec
 - lib/ldclient-rb.rb