ldclient-rb 4.0.0 → 5.0.0

data/lib/ldclient-rb/user_filter.rb

@@ -1,4 +1,5 @@
 require "json"
+require "set"
 
 module LaunchDarkly
   class UserFilter

data/lib/ldclient-rb/util.rb

@@ -0,0 +1,18 @@
+
+module LaunchDarkly
+  module Util
+    def self.http_error_recoverable?(status)
+      if status >= 400 && status < 500
+        status == 400 || status == 408 || status == 429
+      else
+        true
+      end
+    end
+
+    def self.http_error_message(status, context, recoverable_message)
+      desc = (status == 401 || status == 403) ? " (invalid SDK key)" : ""
+      message = Util.http_error_recoverable?(status) ? recoverable_message : "giving up permanently"
+      "HTTP error #{status}#{desc} for #{context} - #{message}"
+    end
+  end
+end

data/lib/ldclient-rb/version.rb

@@ -1,3 +1,3 @@
 module LaunchDarkly
-  VERSION = "4.0.0"
+  VERSION = "5.0.0"
 end

data/lib/sse_client.rb

@@ -0,0 +1,4 @@
+require "sse_client/streaming_http"
+require "sse_client/sse_events"
+require "sse_client/backoff"
+require "sse_client/sse_client"

data/lib/sse_client/backoff.rb

@@ -0,0 +1,38 @@
+
+module SSE
+  #
+  # A simple backoff algorithm that can be reset at any time, or reset itself after a given
+  # interval has passed without errors.
+  #
+  class Backoff
+    def initialize(base_interval, max_interval, auto_reset_interval = 60)
+      @base_interval = base_interval
+      @max_interval = max_interval
+      @auto_reset_interval = auto_reset_interval
+      @attempts = 0
+      @last_good_time = nil
+      @jitter_rand = Random.new
+    end
+
+    attr_accessor :base_interval
+
+    def next_interval
+      if !@last_good_time.nil? && (Time.now.to_i - @last_good_time) >= @auto_reset_interval
+        @attempts = 0
+      end
+      @last_good_time = nil
+      if @attempts == 0
+        @attempts += 1
+        return 0
+      end
+      @last_good_time = nil
+      target = ([@base_interval * (2 ** @attempts), @max_interval].min).to_f
+      @attempts += 1
+      (target / 2) + @jitter_rand.rand(target / 2)
+    end
+
+    def mark_success
+      @last_good_time = Time.now.to_i if @last_good_time.nil?
+    end
+  end
+end

data/lib/sse_client/sse_client.rb

@@ -0,0 +1,162 @@
+require "concurrent/atomics"
+require "logger"
+require "thread"
+require "uri"
+
+module SSE
+  #
+  # A lightweight Server-Sent Events implementation, relying on two gems: socketry for sockets with
+  # read timeouts, and http_tools for HTTP response parsing. The overall logic is based on
+  # [https://github.com/Tonkpils/celluloid-eventsource].
+  #
+  class SSEClient
+    DEFAULT_CONNECT_TIMEOUT = 10
+    DEFAULT_READ_TIMEOUT = 300
+    DEFAULT_RECONNECT_TIME = 1
+    MAX_RECONNECT_TIME = 30
+
+    def initialize(uri, options = {})
+      @uri = URI(uri)
+      @stopped = Concurrent::AtomicBoolean.new(false)
+
+      @headers = options[:headers] ? options[:headers].clone : {}
+      @connect_timeout = options[:connect_timeout] || DEFAULT_CONNECT_TIMEOUT
+      @read_timeout = options[:read_timeout] || DEFAULT_READ_TIMEOUT
+      @logger = options[:logger] || default_logger
+
+      if options[:proxy]
+        @proxy = options[:proxy]
+      else
+        proxyUri = @uri.find_proxy
+        if !proxyUri.nil? && (proxyUri.scheme == 'http' || proxyUri.scheme == 'https')
+          @proxy = proxyUri
+        end
+      end
+
+      reconnect_time = options[:reconnect_time] || DEFAULT_RECONNECT_TIME
+      @backoff = Backoff.new(reconnect_time, MAX_RECONNECT_TIME)
+
+      @on = { event: ->(_) {}, error: ->(_) {} }
+      @last_id = nil
+
+      yield self if block_given?
+
+      Thread.new do
+        run_stream
+      end
+    end
+
+    def on(event_name, &action)
+      @on[event_name.to_sym] = action
+    end
+
+    def on_event(&action)
+      @on[:event] = action
+    end
+
+    def on_error(&action)
+      @on[:error] = action
+    end
+
+    def close
+      if @stopped.make_true
+        @cxn.close if !@cxn.nil?
+      end
+    end
+
+    private
+
+    def default_logger
+      log = ::Logger.new($stdout)
+      log.level = ::Logger::WARN
+      log
+    end
+
+    def run_stream
+      while !@stopped.value
+        @cxn = nil
+        begin
+          @cxn = connect
+          read_stream(@cxn) if !@cxn.nil?
+        rescue Errno::EBADF
+          # don't log this - it probably means we closed our own connection deliberately
+        rescue StandardError => e
+          @logger.error { "Unexpected error from event source: #{e.inspect}" }
+          @logger.debug { "Exception trace: #{e.backtrace}" }
+        end
+        @cxn.close if !cxn.nil?
+      end
+    end
+
+    # Try to establish a streaming connection. Returns the StreamingHTTPConnection object if successful.
+    def connect
+      loop do
+        return if @stopped.value
+        interval = @backoff.next_interval
+        if interval > 0
+          @logger.warn { "Will retry connection after #{'%.3f' % interval} seconds" } 
+          sleep(interval)
+        end
+        begin
+          cxn = open_connection(build_headers)
+          if cxn.status != 200
+            body = cxn.read_all  # grab the whole response body in case it has error details
+            cxn.close
+            @on[:error].call({status_code: cxn.status, body: body})
+            next
+          elsif cxn.headers["content-type"] && cxn.headers["content-type"].start_with?("text/event-stream")
+            return cxn  # we're good to proceed
+          end
+          @logger.error { "Event source returned unexpected content type '#{cxn.headers["content-type"]}'" }
+        rescue Errno::EBADF
+          raise
+        rescue StandardError => e
+          @logger.error { "Unexpected error from event source: #{e.inspect}" }
+          @logger.debug { "Exception trace: #{e.backtrace}" }
+          cxn.close if !cxn.nil?
+        end
+        # if unsuccessful, continue the loop to connect again
+      end
+    end
+
+    # Just calls the StreamingHTTPConnection constructor - factored out for test purposes
+    def open_connection(headers)
+      StreamingHTTPConnection.new(@uri, @proxy, headers, @connect_timeout, @read_timeout)
+    end
+
+    # Pipe the output of the StreamingHTTPConnection into the EventParser, and dispatch events as
+    # they arrive.
+    def read_stream(cxn)
+      event_parser = EventParser.new(cxn.read_lines)
+      event_parser.items.each do |item|
+        return if @stopped.value
+        case item
+          when SSEEvent
+            dispatch_event(item)
+          when SSESetRetryInterval
+            @backoff.base_interval = event.milliseconds.t-Of / 1000
+        end
+      end
+    end
+
+    def dispatch_event(event)
+      @last_id = event.id
+
+      # Tell the Backoff object that as of the current time, we have succeeded in getting some data. It
+      # uses that information so it can automatically reset itself if enough time passes between failures.
+      @backoff.mark_success
+
+      # Pass the event to the caller
+      @on[:event].call(event)
+    end
+
+    def build_headers
+      h = {
+        'Accept' => 'text/event-stream',
+        'Cache-Control' => 'no-cache'
+      }
+      h['Last-Event-Id'] = @last_id if !@last_id.nil?
+      h.merge(@headers)
+    end
+  end
+end

data/lib/sse_client/sse_events.rb

@@ -0,0 +1,67 @@
+
+module SSE
+  # Server-Sent Event type used by SSEClient and EventParser.
+  SSEEvent = Struct.new(:type, :data, :id)
+
+  SSESetRetryInterval = Struct.new(:milliseconds)
+
+  #
+  # Accepts lines of text via an iterator, and parses them into SSE messages.
+  #
+  class EventParser
+    def initialize(lines)
+      @lines = lines
+      reset_buffers
+    end
+
+    # Generator that parses the input interator and returns instances of SSEEvent or SSERetryInterval.
+    def items
+      Enumerator.new do |gen|
+        @lines.each do |line|
+          line.chomp!
+          if line.empty?
+            event = maybe_create_event
+            reset_buffers
+            gen.yield event if !event.nil?
+          else
+            case line
+              when /^(\w+): ?(.*)$/
+                item = process_field($1, $2)
+                gen.yield item if !item.nil?
+            end
+          end
+        end
+      end
+    end
+
+    private
+
+    def reset_buffers
+      @id = nil
+      @type = nil
+      @data = ""
+    end
+
+    def process_field(name, value)
+      case name
+        when "event"
+          @type = value.to_sym
+        when "data"
+          @data << "\n" if !@data.empty?
+          @data << value
+        when "id"
+          @id = value
+        when "retry"
+          if /^(?<num>\d+)$/ =~ value
+            return SSESetRetryInterval.new(num.to_i)
+          end
+      end
+      nil
+    end
+
+    def maybe_create_event
+      return nil if @data.empty?
+      SSEEvent.new(@type || :message, @data, @id)
+    end
+  end
+end

data/lib/sse_client/streaming_http.rb

@@ -0,0 +1,195 @@
+require "http_tools"
+require "socketry"
+
+module SSE
+  #
+  # Wrapper around a socket providing a simplified HTTP request-response cycle including streaming.
+  # The socket is created and managed by Socketry, which we use so that we can have a read timeout.
+  #
+  class StreamingHTTPConnection
+    attr_reader :status, :headers
+
+    def initialize(uri, proxy, headers, connect_timeout, read_timeout)
+      @socket = HTTPConnectionFactory.connect(uri, proxy, connect_timeout, read_timeout)
+      @socket.write(build_request(uri, headers))
+      @reader = HTTPResponseReader.new(@socket, read_timeout)
+      @status = @reader.status
+      @headers = @reader.headers
+    end
+
+    def close
+      @socket.close if @socket
+      @socket = nil
+    end
+    
+    # Generator that returns one line of the response body at a time (delimited by \r, \n,
+    # or \r\n) until the response is fully consumed or the socket is closed.
+    def read_lines
+      @reader.read_lines
+    end
+
+    # Consumes the entire response body and returns it.
+    def read_all
+      @reader.read_all
+    end
+
+    private
+
+    # Build an HTTP request line and headers.
+    def build_request(uri, headers)
+      ret = "GET #{uri.request_uri} HTTP/1.1\r\n"
+      ret << "Host: #{uri.host}\r\n"
+      headers.each { |k, v|
+        ret << "#{k}: #{v}\r\n"
+      }
+      ret + "\r\n"
+    end
+  end
+
+  #
+  # Used internally to send the HTTP request, including the proxy dialogue if necessary.
+  #
+  class HTTPConnectionFactory
+    def self.connect(uri, proxy, connect_timeout, read_timeout)
+      if !proxy
+        return open_socket(uri, connect_timeout)
+      end
+
+      socket = open_socket(proxy, connect_timeout)
+      socket.write(build_proxy_request(uri, proxy))
+
+      # temporarily create a reader just for the proxy connect response
+      proxy_reader = HTTPResponseReader.new(socket, read_timeout)
+      if proxy_reader.status != 200
+        raise ProxyError, "proxy connection refused, status #{proxy_reader.status}"
+      end
+
+      # start using TLS at this point if appropriate
+      if uri.scheme.downcase == 'https'
+        wrap_socket_in_ssl_socket(socket)
+      else
+        socket
+      end
+    end
+
+    private
+
+    def self.open_socket(uri, connect_timeout)
+      if uri.scheme.downcase == 'https'
+        Socketry::SSL::Socket.connect(uri.host, uri.port, timeout: connect_timeout)
+      else
+        Socketry::TCP::Socket.connect(uri.host, uri.port, timeout: connect_timeout)
+      end
+    end
+
+    # Build a proxy connection header.
+    def self.build_proxy_request(uri, proxy)
+      ret = "CONNECT #{uri.host}:#{uri.port} HTTP/1.1\r\n"
+      ret << "Host: #{uri.host}:#{uri.port}\r\n"
+      if proxy.user || proxy.password
+        encoded_credentials = Base64.strict_encode64([proxy.user || '', proxy.password || ''].join(":"))
+        ret << "Proxy-Authorization: Basic #{encoded_credentials}\r\n"
+      end
+      ret << "\r\n"
+      ret
+    end
+
+    def self.wrap_socket_in_ssl_socket(socket)
+      io = IO.try_convert(socket)
+      ssl_sock = OpenSSL::SSL::SSLSocket.new(io, OpenSSL::SSL::SSLContext.new)
+      ssl_sock.connect
+      Socketry::SSL::Socket.new.from_socket(ssl_sock)
+    end
+  end
+
+  class ProxyError < StandardError
+    def initialize(message)
+      super
+    end
+  end
+
+  #
+  # Used internally to read the HTTP response, either all at once or as a stream of text lines.
+  # Incoming data is fed into an instance of HTTPTools::Parser, which gives us the header and
+  # chunks of the body via callbacks.
+  #
+  class HTTPResponseReader
+    DEFAULT_CHUNK_SIZE = 10000
+
+    attr_reader :status, :headers
+
+    def initialize(socket, read_timeout)
+      @socket = socket
+      @read_timeout = read_timeout
+      @parser = HTTPTools::Parser.new
+      @buffer = ""
+      @done = false
+      @lock = Mutex.new
+
+      # Provide callbacks for the Parser to give us the headers and body. This has to be done
+      # before we start piping any data into the parser.
+      have_headers = false
+      @parser.on(:header) do
+        have_headers = true
+      end
+      @parser.on(:stream) do |data|
+        @lock.synchronize { @buffer << data }  # synchronize because we're called from another thread in Socketry
+      end
+      @parser.on(:finish) do
+        @lock.synchronize { @done = true }
+      end
+
+      # Block until the status code and headers have been successfully read.
+      while !have_headers
+        raise EOFError if !read_chunk_into_buffer
+      end
+      @headers = Hash[@parser.header.map { |k,v| [k.downcase, v] }]
+      @status = @parser.status_code
+    end
+
+    def read_lines
+      Enumerator.new do |gen|
+        loop do
+          line = read_line
+          break if line.nil?
+          gen.yield line
+        end
+      end
+    end
+
+    def read_all
+      while read_chunk_into_buffer
+      end
+      @buffer
+    end
+
+    private
+
+    # Attempt to read some more data from the socket. Return true if successful, false if EOF.
+    # A read timeout will result in an exception from Socketry's readpartial method.
+    def read_chunk_into_buffer
+      # If @done is set, it means the Parser has signaled end of response body
+      @lock.synchronize { return false if @done }
+      data = @socket.readpartial(DEFAULT_CHUNK_SIZE, timeout: @read_timeout)
+      return false if data == :eof
+      @parser << data
+      # We are piping the content through the parser so that it can handle things like chunked
+      # encoding for us. The content ends up being appended to @buffer via our callback.
+      true
+    end
+
+    # Extract the next line of text from the read buffer, refilling the buffer as needed.
+    def read_line
+      loop do
+        @lock.synchronize do
+          i = @buffer.index(/[\r\n]/)
+          if !i.nil?
+            i += 1 if (@buffer[i] == "\r" && i < @buffer.length - 1 && @buffer[i + 1] == "\n")
+            return @buffer.slice!(0, i + 1).force_encoding(Encoding::UTF_8)
+          end
+        end
+        return nil if !read_chunk_into_buffer
+      end
+    end
+  end
+end