ld-eventsource 2.1.0 → 2.2.1

data/.ldrelease/config.yml

@@ -1,22 +0,0 @@
-repo:
-  public: ruby-eventsource
-
-publications:
-  - url: https://rubygems.org/gems/ld-eventsource
-    description: RubyGems
-  - url: https://www.rubydoc.info/gems/ld-eventsource
-    description: documentation
-
-releasableBranches:
-  - name: master
-    description: 2.x - based on the http gem
-  - name: 1.x
-    description: 1.x - based on the socketry gem
-
-circleci:
-  linux:
-    image: cimg/ruby:2.5
-    context: org-global
-
-template:
-  name: ruby

data/CHANGELOG.md

@@ -1,35 +0,0 @@
-# Change log
-
-All notable changes to the LaunchDarkly SSE Client for Ruby will be documented in this file. This project adheres to [Semantic Versioning](http://semver.org).
-
-## [2.0.1] - 2021-08-10
-### Changed:
-- The dependency version constraint for the `http` gem is now looser: it allows 5.x versions as well as 4.x. The breaking changes in `http` v5.0.0 do not affect `ld-eventsource`.
-- The project's build now uses v2.2.10 of `bundler` due to known vulnerabilities in other versions.
-- `Gemfile.lock` has been removed from source control. As this is a library project, the lockfile never affected application code that used this gem, but only affected the gem's own CI build. It is preferable for the CI build to refer only to the gemspec so that it resolves dependencies the same way an application using this gem would, rather than using pinned dependencies that an application would not use.
-
-## [2.0.0] - 2021-01-26
-### Added:
-- Added a `socket_factory` configuration option which can be used for socket creation by the HTTP client if provided. The value of `socket_factory` must be an object providing an `open(uri, timeout)` method and returning a connected socket.
-
-### Changed:
-- Switched to the `http` gem instead of `socketry` and a custom HTTP client.
-- Dropped support for Ruby < version 2.5
-- Dropped support for JRuby < version 9.2
-
-## [1.0.3] - 2020-03-17
-### Fixed:
-- The backoff delay logic for reconnecting after a stream failure was broken so that if a failure occurred after a stream had been active for at least `reconnect_reset_interval` (default 60 seconds), retries would use _no_ delay, potentially causing a flood of requests and a spike in CPU usage.
-
-## [1.0.2] - 2020-03-10
-### Removed:
-- Removed an unused dependency on `rake`. There are no other changes in this release.
-
-
-## [1.0.1] - 2019-07-10
-### Fixed:
-- Calling `close` on the client could cause a misleading warning message in the log, such as `Unexpected error from event source: #<IOError: stream closed in another thread>`.
-
-## [1.0.0] - 2019-01-03
-
-Initial release.

data/Gemfile

@@ -1,3 +0,0 @@
-source "https://rubygems.org"
-
-gemspec

data/ld-eventsource.gemspec

@@ -1,30 +0,0 @@
-# coding: utf-8
-
-lib = File.expand_path("../lib", __FILE__)
-$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
-require "ld-eventsource/version"
-
-# rubocop:disable Metrics/BlockLength
-Gem::Specification.new do |spec|
-  spec.name          = "ld-eventsource"
-  spec.version       = SSE::VERSION
-  spec.authors       = ["LaunchDarkly"]
-  spec.email         = ["team@launchdarkly.com"]
-  spec.summary       = "LaunchDarkly SSE client"
-  spec.description   = "LaunchDarkly SSE client for Ruby"
-  spec.homepage      = "https://github.com/launchdarkly/ruby-eventsource"
-  spec.license       = "Apache-2.0"
-
-  spec.files         = `git ls-files -z`.split("\x0")
-  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
-  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
-  spec.require_paths = ["lib"]
-
-  spec.add_development_dependency "bundler", "2.2.10"
-  spec.add_development_dependency "rspec", "~> 3.2"
-  spec.add_development_dependency "rspec_junit_formatter", "~> 0.3.0"
-  spec.add_development_dependency "webrick", "~> 1.7"
-
-  spec.add_runtime_dependency "concurrent-ruby", "~> 1.0"
-  spec.add_runtime_dependency "http", ">= 4.4.1", "< 6.0.0"
-end

data/scripts/gendocs.sh

@@ -1,12 +0,0 @@
-#!/bin/bash
-
-# Use this script to generate documentation locally in ./doc so it can be proofed before release.
-# After release, documentation will be visible at https://www.rubydoc.info/gems/ld-eventsource
-
-gem install --conservative yard
-gem install --conservative redcarpet  # provides Markdown formatting
-
-# yard doesn't seem to do recursive directories, even though Ruby's Dir.glob supposedly recurses for "**"
-PATHS="lib/*.rb lib/**/*.rb lib/**/**/*.rb"
-
-yard doc --no-private --markup markdown --markup-provider redcarpet --embed-mixins $PATHS - README.md

data/scripts/release.sh

@@ -1,30 +0,0 @@
-#!/usr/bin/env bash
-
-# This script updates the version for the library and releases it to RubyGems
-# It will only work if you have the proper credentials set up in ~/.gem/credentials
-
-# It takes exactly one argument: the new version.
-# It should be run from the root of this git repo like this:
-#   ./scripts/release.sh 4.0.9
-
-# When done you should commit and push the changes made.
-
-set -uxe
-
-VERSION=$1
-GEM_NAME=ld-eventsource
-
-echo "Starting $GEM_NAME release."
-
-# Update version in version.rb
-VERSION_RB_TEMP=./version.rb.tmp
-sed "s/VERSION =.*/VERSION = \"${VERSION}\"/g" lib/$GEM_NAME/version.rb > ${VERSION_RB_TEMP}
-mv ${VERSION_RB_TEMP} lib/$GEM_NAME/version.rb
-
-# Build Ruby gem
-gem build $GEM_NAME.gemspec
-
-# Publish Ruby gem
-gem push $GEM_NAME-${VERSION}.gem
-
-echo "Done with $GEM_NAME release"

data/spec/backoff_spec.rb

@@ -1,52 +0,0 @@
-require "ld-eventsource"
-
-require "http_stub"
-
-module SSE
-  module Impl
-    describe Backoff do
-      it "increases exponentially with jitter" do
-        initial = 1.5
-        max = 60
-        b = Backoff.new(initial, max)
-        previous = 0
-
-        for i in 1..6 do
-          interval = b.next_interval
-          expect(interval).to be > previous
-          target = initial * (2 ** (i - 1))
-          expect(interval).to be <= target
-          expect(interval).to be >= target / 2
-          previous = i
-        end
-
-        interval = b.next_interval
-        expect(interval).to be >= previous
-        expect(interval).to be <= max
-      end
-
-      it "resets to initial delay if reset threshold has elapsed" do
-        initial = 1.5
-        max = 60
-        threshold = 2
-        b = Backoff.new(initial, max, reconnect_reset_interval: threshold)
-
-        for i in 1..6 do
-          # just cause the backoff to increase quickly, don't actually do these delays
-          b.next_interval
-        end
-
-        b.mark_success
-        sleep(threshold + 0.001)
-
-        interval = b.next_interval
-        expect(interval).to be <= initial
-        expect(interval).to be >= initial / 2
-
-        interval = b.next_interval # make sure it continues increasing after that
-        expect(interval).to be <= (initial * 2)
-        expect(interval).to be >= initial
-      end
-    end
-  end
-end

data/spec/client_spec.rb

@@ -1,444 +0,0 @@
-require "ld-eventsource"
-
-#
-# End-to-end tests of the SSE client against a real server
-#
-describe SSE::Client do
-  subject { SSE::Client }
-
-  let(:simple_event_1) { SSE::StreamEvent.new(:go, "foo", "a")}
-  let(:simple_event_2) { SSE::StreamEvent.new(:stop, "bar", "b")}
-  let(:simple_event_1_text) { <<-EOT
-event: go
-data: foo
-id: a
-
-EOT
-  }
-  let(:simple_event_2_text) { <<-EOT
-event: stop
-data: bar
-id: b
-
-EOT
-  }
-  let(:reconnect_asap) { 0.01 }
-
-  def with_client(client)
-    begin
-      yield client
-    ensure
-      client.close
-    end
-  end
-
-  def send_stream_content(res, content, keep_open:)
-    res.content_type = "text/event-stream"
-    res.status = 200
-    res.chunked = true
-    rd, wr = IO.pipe
-    wr.write(content)
-    res.body = rd
-    if !keep_open
-      wr.close
-    end
-    wr
-  end
-
-  it "sends expected headers" do
-    with_server do |server|
-      requests = Queue.new
-      server.setup_response("/") do |req,res|
-        requests << req
-        send_stream_content(res, "", keep_open: true)
-      end
-      
-      headers = { "Authorization" => "secret" }
-
-      with_client(subject.new(server.base_uri, headers: headers)) do |client|
-        received_req = requests.pop
-        expect(received_req.header).to eq({
-          "accept" => ["text/event-stream"],
-          "cache-control" => ["no-cache"],
-          "host" => ["127.0.0.1:" + server.port.to_s],
-          "authorization" => ["secret"],
-          "user-agent" => ["ruby-eventsource"],
-          "content-length" => ["0"],
-          "connection" => ["close"]
-        })
-      end
-    end
-  end
-
-  it "sends initial Last-Event-Id if specified" do
-    id = "xyz"
-    with_server do |server|
-      requests = Queue.new
-      server.setup_response("/") do |req,res|
-        requests << req
-        send_stream_content(res, "", keep_open: true)
-      end
-      
-      headers = { "Authorization" => "secret" }
-
-      with_client(subject.new(server.base_uri, headers: headers, last_event_id: id)) do |client|
-        received_req = requests.pop
-        expect(received_req.header).to eq({
-          "accept" => ["text/event-stream"],
-          "cache-control" => ["no-cache"],
-          "host" => ["127.0.0.1:" + server.port.to_s],
-          "authorization" => ["secret"],
-          "last-event-id" => [id],
-          "user-agent" => ["ruby-eventsource"],
-          "content-length" => ["0"],
-          "connection" => ["close"]
-        })
-      end
-    end
-  end
-
-  it "receives messages" do
-    events_body = simple_event_1_text + simple_event_2_text
-    with_server do |server|
-      server.setup_response("/") do |req,res|
-        send_stream_content(res, events_body, keep_open: true)
-      end
-
-      event_sink = Queue.new
-      client = subject.new(server.base_uri) do |c|
-        c.on_event { |event| event_sink << event }
-      end
-
-      with_client(client) do |client|
-        expect(event_sink.pop).to eq(simple_event_1)
-        expect(event_sink.pop).to eq(simple_event_2)
-      end
-    end
-  end
-
-  it "does not trigger an error when stream is closed" do
-    events_body = simple_event_1_text + simple_event_2_text
-    with_server do |server|
-      server.setup_response("/") do |req,res|
-        send_stream_content(res, events_body, keep_open: true)
-      end
-
-      event_sink = Queue.new
-      error_sink = Queue.new
-      client = subject.new(server.base_uri) do |c|
-        c.on_event { |event| event_sink << event }
-        c.on_error { |error| error_sink << error }
-      end
-
-      with_client(client) do |client|
-        event_sink.pop  # wait till we have definitely started reading the stream
-        client.close
-        sleep 0.25  # there's no way to really know when the stream thread has finished
-        expect(error_sink.empty?).to be true
-      end
-    end
-  end
-
-  it "reconnects after error response" do
-    events_body = simple_event_1_text
-    with_server do |server|
-      attempt = 0
-      server.setup_response("/") do |req,res|
-        attempt += 1
-        if attempt == 1
-          res.status = 500
-          res.body = "sorry"
-          res.keep_alive = false
-        else
-          send_stream_content(res, events_body, keep_open: true)
-        end
-      end
-
-      event_sink = Queue.new
-      error_sink = Queue.new
-      client = subject.new(server.base_uri, reconnect_time: reconnect_asap) do |c|
-        c.on_event { |event| event_sink << event }
-        c.on_error { |error| error_sink << error }
-      end
-
-      with_client(client) do |client|
-        expect(event_sink.pop).to eq(simple_event_1)
-        expect(error_sink.pop).to eq(SSE::Errors::HTTPStatusError.new(500, "sorry"))
-        expect(attempt).to eq 2
-      end
-    end
-  end
-
-  it "reconnects after invalid content type" do
-    events_body = simple_event_1_text
-    with_server do |server|
-      attempt = 0
-      server.setup_response("/") do |req,res|
-        attempt += 1
-        if attempt == 1
-          res.status = 200
-          res.content_type = "text/plain"
-          res.body = "sorry"
-          res.keep_alive = false
-        else
-          send_stream_content(res, events_body, keep_open: true)
-        end
-      end
-
-      event_sink = Queue.new
-      error_sink = Queue.new
-      client = subject.new(server.base_uri, reconnect_time: reconnect_asap) do |c|
-        c.on_event { |event| event_sink << event }
-        c.on_error { |error| error_sink << error }
-      end
-
-      with_client(client) do |client|
-        expect(event_sink.pop).to eq(simple_event_1)
-        expect(error_sink.pop).to eq(SSE::Errors::HTTPContentTypeError.new("text/plain"))
-        expect(attempt).to eq 2
-      end
-    end
-  end
-
-  it "reconnects after read timeout" do
-    events_body = simple_event_1_text
-    with_server do |server|
-      attempt = 0
-      server.setup_response("/") do |req,res|
-        attempt += 1
-        if attempt == 1
-          sleep(1)
-        end
-        send_stream_content(res, events_body, keep_open: true)
-      end
-
-      event_sink = Queue.new
-      client = subject.new(server.base_uri, reconnect_time: reconnect_asap, read_timeout: 0.25) do |c|
-        c.on_event { |event| event_sink << event }
-      end
-
-      with_client(client) do |client|
-        expect(event_sink.pop).to eq(simple_event_1)
-        expect(attempt).to eq 2
-      end
-    end
-  end
-
-  it "reconnects if stream returns EOF" do
-    with_server do |server|
-      attempt = 0
-      server.setup_response("/") do |req,res|
-        attempt += 1
-        send_stream_content(res, attempt == 1 ? simple_event_1_text : simple_event_2_text,
-          keep_open: attempt == 2)
-      end
-
-      event_sink = Queue.new
-      client = subject.new(server.base_uri, reconnect_time: reconnect_asap) do |c|
-        c.on_event { |event| event_sink << event }
-      end
-
-      with_client(client) do |client|
-        expect(event_sink.pop).to eq(simple_event_1)
-        expect(event_sink.pop).to eq(simple_event_2)
-        expect(attempt).to eq 2
-      end
-    end
-  end
-
-  it "sends ID of last received event, if any, when reconnecting" do
-    with_server do |server|
-      requests = Queue.new
-      attempt = 0
-      server.setup_response("/") do |req,res|
-        requests << req
-        attempt += 1
-        send_stream_content(res, attempt == 1 ? simple_event_1_text : simple_event_2_text,
-          keep_open: attempt == 2)
-      end
-
-      event_sink = Queue.new
-      client = subject.new(server.base_uri, reconnect_time: reconnect_asap) do |c|
-        c.on_event { |event| event_sink << event }
-      end
-
-      with_client(client) do |client|
-        req1 = requests.pop
-        req2 = requests.pop
-        expect(req2.header["last-event-id"]).to eq([ simple_event_1.id ])
-      end
-    end
-  end
-
-  it "increases backoff delay if a failure happens within the reset threshold" do
-    request_times = []
-    max_requests = 5
-    initial_interval = 0.25
-
-    with_server do |server|
-      attempt = 0
-      server.setup_response("/") do |req,res|
-        request_times << Time.now
-        attempt += 1
-        send_stream_content(res, simple_event_1_text, keep_open: attempt == max_requests)
-      end
-
-      event_sink = Queue.new
-      client = subject.new(server.base_uri, reconnect_time: initial_interval) do |c|
-        c.on_event { |event| event_sink << event }
-      end
-
-      with_client(client) do |client|
-        last_interval = nil
-        max_requests.times do |i|
-          expect(event_sink.pop).to eq(simple_event_1)
-          if i > 0
-            interval = request_times[i] - request_times[i - 1]
-            minimum_expected_interval = initial_interval * (2 ** (i - 1)) / 2
-            expect(interval).to be >= minimum_expected_interval
-            last_interval = interval
-          end
-        end
-      end
-    end
-  end
-
-  it "resets backoff delay if a failure happens after the reset threshold" do
-    request_times = []
-    request_end_times = []
-    max_requests = 5
-    threshold = 0.3
-    initial_interval = 0.25
-
-    with_server do |server|
-      attempt = 0
-      server.setup_response("/") do |req,res|
-        request_times << Time.now
-        attempt += 1
-        stream = send_stream_content(res, simple_event_1_text, keep_open: true)
-        Thread.new do
-          sleep(threshold + 0.01)
-          stream.close
-          request_end_times << Time.now
-        end
-      end
-
-      event_sink = Queue.new
-      client = subject.new(server.base_uri, reconnect_time: initial_interval, reconnect_reset_interval: threshold) do |c|
-        c.on_event { |event| event_sink << event }
-      end
-
-      with_client(client) do |client|
-        last_interval = nil
-        max_requests.times do |i|
-          expect(event_sink.pop).to eq(simple_event_1)
-          if i > 0
-            interval = request_times[i] - request_end_times[i - 1]
-            expect(interval).to be <= (initial_interval + 0.1)
-          end
-        end
-      end
-    end
-  end
-
-  it "can change initial reconnect delay based on directive from server" do
-    request_times = []
-    configured_interval = 1
-    retry_ms = 100
-
-    with_server do |server|
-      attempt = 0
-      server.setup_response("/") do |req,res|
-        request_times << Time.now
-        attempt += 1
-        if attempt == 1
-          send_stream_content(res, "retry: #{retry_ms}\n", keep_open: false)
-        else
-          send_stream_content(res, simple_event_1_text, keep_open: true)
-        end
-      end
-
-      event_sink = Queue.new
-      client = subject.new(server.base_uri, reconnect_time: configured_interval) do |c|
-        c.on_event { |event| event_sink << event }
-      end
-
-      with_client(client) do |client|
-        expect(event_sink.pop).to eq(simple_event_1)
-        interval = request_times[1] - request_times[0]
-        expect(interval).to be < 0.5
-      end
-    end
-  end
-
-  it "connects to HTTP server through proxy" do
-    events_body = simple_event_1_text
-    with_server do |server|
-      server.setup_response("/") do |req,res|
-        send_stream_content(res, events_body, keep_open: false)
-      end
-      with_server(StubProxyServer.new) do |proxy|
-        event_sink = Queue.new
-        client = subject.new(server.base_uri, proxy: proxy.base_uri) do |c|
-          c.on_event { |event| event_sink << event }
-        end
-
-        with_client(client) do |client|
-          expect(event_sink.pop).to eq(simple_event_1)
-          expect(proxy.request_count).to eq(1)
-        end
-      end
-    end
-  end
-
-  it "resets read timeout between events" do
-    event_body = simple_event_1_text
-    with_server do |server|
-      attempt = 0
-      server.setup_response("/") do |req,res|
-        attempt += 1
-        if attempt == 1
-          stream = send_stream_content(res, event_body, keep_open: true)
-          Thread.new do
-            2.times {
-              # write within timeout interval
-              sleep(0.75)
-              stream.write(event_body)
-            }
-            # cause timeout
-            sleep(1.25)
-          end
-        elsif attempt == 2
-          send_stream_content(res, event_body, keep_open: false)
-        end
-      end
-
-      event_sink = Queue.new
-      client = subject.new(server.base_uri, reconnect_time: reconnect_asap, read_timeout: 1) do |c|
-        c.on_event { |event| event_sink << event }
-      end
-
-      with_client(client) do |client|
-        4.times {
-          expect(event_sink.pop).to eq(simple_event_1)
-        }
-        expect(attempt).to eq 2
-      end
-    end
-  end
-
-  it "returns true from closed? when closed" do
-    with_server do |server|
-      server.setup_response("/") do |req,res|
-        send_stream_content(res, "", keep_open: true)
-      end
-      
-      with_client(subject.new(server.base_uri)) do |client|
-        expect(client.closed?).to be(false)
-
-        client.close
-        expect(client.closed?).to be(true)
-      end
-    end
-  end
-end