ldclient-rb 5.4.3 → 5.5.0

data/lib/sse_client.rb

@@ -1,4 +0,0 @@
-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

@@ -1,38 +0,0 @@
-
-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

@@ -1,171 +0,0 @@
-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?
-        @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
-          # There's a potential race if close was called in the middle of the previous line, i.e. after we
-          # connected but before @cxn was set. Checking the variable again is a bit clunky but avoids that.
-          return if @stopped.value
-          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
-        begin
-          @cxn.close if !@cxn.nil?
-        rescue StandardError => e
-          @logger.error { "Unexpected error while closing stream: #{e.inspect}" }
-          @logger.debug { "Exception trace: #{e.backtrace}" }
-        end
-      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

@@ -1,67 +0,0 @@
-
-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

@@ -1,199 +0,0 @@
-require "concurrent/atomics"
-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
-      @closed = Concurrent::AtomicBoolean.new(false)
-    end
-
-    def close
-      if @closed.make_true
-        @socket.close if @socket
-        @socket = nil
-      end
-    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