honeymaker 0.11.5 → 0.11.9

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: d279d1416ac845778e5bf48218fbacf23498cae10bc1ed589cae28752aa4af8c
-  data.tar.gz: 2aebe8b36d740f1c09bb9ecf21ab205b911f6ce11fc41b0a7bc80898602d016f
+  metadata.gz: e6f44f3c6ed35e460dcb6b6d53a73bebec433c34ad1109ab8b1531f799ad93b0
+  data.tar.gz: cd55a0b081c84f712e67ba00ede7633764592b0ff97d2b47fa50f29fc7c0cdd0
 SHA512:
-  metadata.gz: ae37fa13ff7ce2db5366a408a4d006f671fcbda1c8931c8bca9c8df8a3c13c1256101a73b364bbffc58971923090d5dd8b0e44b49fdc35f73a0ecee8979f67b6
-  data.tar.gz: 0a00d2949aeba2b30b681a8021b59083de3498d201446e70ba88e1c2ccfa135f6137036620559f1e79cc2f216328639a3bf61d47f1082fa73040aa60389967c0
+  metadata.gz: 32e67280cabf17a5a7305660b92ad2ff2eda948fb947a50a771f6bbd102f7cd9cbbeefdda50b09c16d1087bdd637c4649ba25963046828c9dcbd73eec87c5a4b
+  data.tar.gz: 01b15492c985691a7fcde609a56f3f6e197febbf7fdaaace27186ecb66268a128f796e99ca2a28aef7700c7e56bedb753ceff557400c7f54e142b07a7cb36a20

data/lib/honeymaker/client.rb

@@ -61,6 +61,13 @@ module Honeymaker
       raise NotImplementedError, "#{self.class} must implement #validate_read_credentials"
     end
 
+    # No HTTP answer means the transport failed, and its text rarely says how ("end of file
+    # reached"). The chain of exception classes does — whether the request never left or may have
+    # landed — so it travels with the failure. Facts only: what they mean is the caller's call.
+    def transport_data(error, status)
+      status.nil? ? { status: nil, error_chain: Utils.error_chain(error) } : { status: status }
+    end
+
     def with_rescue
       Result::Success.new(yield)
     rescue Faraday::Error => e
@@ -68,7 +75,7 @@ module Honeymaker
       error_message = (body && !body.empty?) ? body : e.message.to_s
       error_message = "Unknown API error" if error_message.nil? || error_message.empty?
       status = e.respond_to?(:response_status) ? e.response_status : nil
-      Result::Failure.new(error_message, data: { status: status })
+      Result::Failure.new(error_message, data: transport_data(e, status))
     rescue StandardError => e
       # NOT an exchange error — a bug here, in a vendor gem, or in the caller, and it arrives in the
       # same Result::Failure as a genuine venue rejection. Callers classify that text to decide "out

data/lib/honeymaker/exchange.rb

@@ -71,13 +71,21 @@ module Honeymaker
 
     private
 
+    # No HTTP answer means the transport failed, and its text rarely says how ("end of file
+    # reached"). The chain of exception classes does — whether the request never left or may have
+    # landed — so it travels with the failure. Facts only: what they mean is the caller's call.
+    def transport_data(error, status)
+      status.nil? ? { status: nil, error_chain: Utils.error_chain(error) } : { status: status }
+    end
+
     def with_rescue
       Result::Success.new(yield)
     rescue Faraday::Error => e
       body = e.respond_to?(:response_body) ? e.response_body : nil
       error_message = (body && !body.empty?) ? body : e.message.to_s
       error_message = "Unknown API error" if error_message.nil? || error_message.empty?
-      Result::Failure.new(error_message)
+      status = e.respond_to?(:response_status) ? e.response_status : nil
+      Result::Failure.new(error_message, data: transport_data(e, status))
     rescue StandardError => e
       msg = e.message
       Result::Failure.new((msg && !msg.empty?) ? msg : "Unknown error")

data/lib/honeymaker/exchanges/gemini.rb

@@ -5,13 +5,25 @@ module Honeymaker
     class Gemini < Exchange
       BASE_URL = "https://api.gemini.com"
 
+      # Gemini has no bulk symbol-details endpoint, so the catalogue is one request per symbol --
+      # ~350 of them against a public limit of 120/min. Unpaced they ran at ~208/min, and a single
+      # dropped connection failed the whole catalogue: the adapter retries nothing on its own.
+      REQUEST_INTERVAL = 0.5
+      REQUEST_ATTEMPTS = 3
+      TRANSIENT_ERRORS = [
+        Faraday::ConnectionFailed, Faraday::TimeoutError, Faraday::RequestTimeoutError,
+        Faraday::TooManyRequestsError, Faraday::ServerError
+      ].freeze
+
       def get_tickers_info
         with_rescue do
-          symbols_response = connection.get("/v1/symbols")
-          symbols = symbols_response.body
+          symbols = catalogue_get("/v1/symbols")
 
-          symbols.filter_map do |symbol|
-            detail = connection.get("/v1/symbols/details/#{symbol}").body
+          tickers = symbols.filter_map do |symbol|
+            # A symbol that still fails raises, failing the WHOLE catalogue. Never skip it: callers
+            # read a pair missing from the catalogue as delisted, and data-api revokes it.
+            detail = catalogue_get("/v1/symbols/details/#{symbol}")
+            next unless spot?(symbol, detail)
 
             tick_size = detail["tick_size"]&.to_s || "0.01"
             quote_increment = detail["quote_increment"]&.to_s || "0.01"
@@ -31,6 +43,7 @@ module Honeymaker
               trading_enabled: detail["status"] == "open"
             }
           end
+          reject_shared_pairs!(tickers)
         end
       end
 
@@ -50,6 +63,39 @@ module Honeymaker
       def connection
         @connection ||= build_connection(BASE_URL)
       end
+
+      # Gemini lists perpetual swaps beside spot, under the same base and quote (BTCGUSDPERP is
+      # BTC/GUSD, product_type "swap"), so only product_type tells them apart. An instrument without
+      # one is not assumed to be spot: the catalogue fails and callers keep the one they have.
+      def spot?(symbol, detail)
+        product_type = detail["product_type"]
+        raise Error, "Gemini #{symbol}: no product_type in its details" unless product_type.is_a?(String)
+
+        product_type == "spot"
+      end
+
+      # One pair, one instrument. Two would leave callers to pick one by list order.
+      def reject_shared_pairs!(tickers)
+        shared = tickers.group_by { |t| "#{t[:base]}/#{t[:quote]}" }.find { |_, group| group.size > 1 }
+        return tickers unless shared
+
+        pair, group = shared
+        raise Error, "Gemini #{pair} is claimed by #{group.map { |t| t[:ticker] }.join(' and ')}"
+      end
+
+      def catalogue_get(path)
+        attempt = 1
+        begin
+          sleep(REQUEST_INTERVAL)
+          connection.get(path).body
+        rescue *TRANSIENT_ERRORS
+          raise if attempt >= REQUEST_ATTEMPTS
+
+          sleep(2**attempt)
+          attempt += 1
+          retry
+        end
+      end
     end
   end
 end

data/lib/honeymaker/utils.rb

@@ -9,6 +9,25 @@ module Honeymaker
       str.split(".").last.length
     end
 
+    # The exception classes behind an error, outermost first, following both Faraday's
+    # #wrapped_exception and Ruby's #cause (adapters nest them differently), each named once.
+    # Reported on a transport failure so a caller can tell where it happened; see Client#with_rescue.
+    def self.error_chain(error, limit: 10)
+      names = []
+      seen = {}.compare_by_identity # exceptions, not classes: adapters re-wrap in the same class
+      queue = [error]
+      until queue.empty? || seen.size >= limit
+        node = queue.shift
+        next if seen.key?(node)
+
+        seen[node] = true
+        names << node.class.name unless names.include?(node.class.name)
+        queue << node.wrapped_exception if node.respond_to?(:wrapped_exception) && node.wrapped_exception
+        queue << node.cause if node.cause
+      end
+      names
+    end
+
     def self.parse_filters(filters)
       {
         price: filters.find { |f| f["filterType"] == "PRICE_FILTER" },

data/lib/honeymaker/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Honeymaker
-  VERSION = "0.11.5"
+  VERSION = "0.11.9"
 end

data/test/fixtures/gemini_symbol_detail.json

@@ -5,5 +5,6 @@
   "tick_size": "0.00000001",
   "quote_increment": "0.01",
   "min_order_size": "0.00001",
-  "status": "open"
+  "status": "open",
+  "product_type": "spot"
 }

data/test/honeymaker/error_chain_test.rb

@@ -0,0 +1,133 @@
+# frozen_string_literal: true
+
+require "test_helper"
+require "socket"
+
+# A transport failure — the request got no HTTP answer at all — carries the chain of exception
+# classes behind it, outermost first. The text of such a failure rarely says what happened
+# ("end of file reached"); the chain does, and it is what lets a caller tell a request that never
+# left (DNS, a refused connection, a proxy refusing CONNECT) from one that may have landed (EOF,
+# reset, read timeout). Honeymaker only reports it; deciding what it means is the caller's job.
+class Honeymaker::ErrorChainTest < Minitest::Test
+  def test_walks_wrapped_exceptions_and_causes_outermost_first
+    error = Faraday::ConnectionFailed.new(EOFError.new("end of file reached"))
+
+    assert_equal %w[Faraday::ConnectionFailed EOFError], Honeymaker::Utils.error_chain(error)
+  end
+
+  def test_follows_ruby_causes_and_names_each_class_once
+    error = begin
+      begin
+        raise Errno::ECONNREFUSED
+      rescue Errno::ECONNREFUSED
+        raise Faraday::ConnectionFailed, "connection refused"
+      end
+    rescue Faraday::ConnectionFailed => e
+      e
+    end
+
+    assert_equal %w[Faraday::ConnectionFailed Errno::ECONNREFUSED], Honeymaker::Utils.error_chain(error)
+  end
+
+  # Adapters re-wrap: a class seen once must not hide what sits beneath its second instance.
+  def test_a_repeated_class_does_not_cut_the_chain_short
+    inner = Faraday::ConnectionFailed.new(Errno::ECONNREFUSED.new)
+    error = Faraday::ConnectionFailed.new(inner)
+
+    assert_equal %w[Faraday::ConnectionFailed Errno::ECONNREFUSED], Honeymaker::Utils.error_chain(error)
+  end
+
+  def test_client_failure_carries_the_chain_and_keeps_its_text
+    result = Honeymaker::Client.new.send(:with_rescue) do
+      raise Faraday::ConnectionFailed, EOFError.new("end of file reached")
+    end
+
+    assert_equal ["end of file reached"], result.errors
+    assert_nil result.data[:status]
+    assert_equal %w[Faraday::ConnectionFailed EOFError], result.data[:error_chain]
+  end
+
+  def test_exchange_failure_carries_the_chain_and_keeps_its_text
+    result = Honeymaker::Exchange.new.send(:with_rescue) do
+      raise Faraday::ConnectionFailed, EOFError.new("end of file reached")
+    end
+
+    assert_equal ["end of file reached"], result.errors
+    assert_equal %w[Faraday::ConnectionFailed EOFError], result.data[:error_chain]
+  end
+
+  # An HTTP answer is not a transport failure: its status says what happened.
+  def test_a_failure_with_an_http_answer_has_no_chain
+    error = Faraday::ServerError.new("boom", { status: 503, body: "unavailable" })
+    [Honeymaker::Client.new, Honeymaker::Exchange.new].each do |receiver|
+      result = receiver.send(:with_rescue) { raise error }
+
+      assert_nil result.data[:error_chain], receiver.class.name
+    end
+  end
+
+  # --- The chains the real adapter produces, against local sockets -------------------------------
+
+  def setup
+    @servers = []
+  end
+
+  # Closing a server makes its blocked #accept raise, which ends the serving thread; joining it
+  # keeps that thread from outliving the test.
+  def teardown
+    @servers.each do |server, thread|
+      server.close
+      thread.join(1)
+    end
+  end
+
+  def test_real_chain_for_a_connection_closed_before_the_answer
+    port = local_server
+
+    assert_equal %w[Faraday::ConnectionFailed EOFError], chain_of("http://127.0.0.1:#{port}")
+  end
+
+  def test_real_chain_for_a_refused_connection
+    port = TCPServer.new("127.0.0.1", 0).then { |s| s.addr[1].tap { s.close } }
+
+    assert_includes chain_of("http://127.0.0.1:#{port}"), "Errno::ECONNREFUSED"
+  end
+
+  def test_real_chain_for_a_proxy_refusing_connect
+    port = local_server("HTTP/1.1 407 Proxy Authentication Required\r\nContent-Length: 0\r\n\r\n")
+    client = Honeymaker::Client.new(proxy: "http://127.0.0.1:#{port}")
+    result = client.send(:with_rescue) { client.send(:build_client_connection, "https://example.com").get("/") }
+
+    assert_equal %w[Faraday::ConnectionFailed Net::HTTPClientException], result.data[:error_chain]
+  end
+
+  private
+
+  # A local server that reads each request and answers with `reply`, or hangs up without an answer
+  # when there is none. Returns its port; teardown closes it.
+  def local_server(reply = nil)
+    server = TCPServer.new("127.0.0.1", 0)
+    thread = Thread.new do
+      loop do
+        client = server.accept
+        begin
+          client.readpartial(4096)
+          client.write(reply) if reply
+        rescue EOFError, SystemCallError
+          nil
+        ensure
+          client.close
+        end
+      end
+    rescue IOError, SystemCallError
+      nil # the server was closed in teardown
+    end
+    @servers << [server, thread]
+    server.addr[1]
+  end
+
+  def chain_of(url)
+    client = Honeymaker::Client.new
+    client.send(:with_rescue) { client.send(:build_client_connection, url).get("/") }.data[:error_chain]
+  end
+end

data/test/honeymaker/exchanges/gemini_test.rb

@@ -7,18 +7,13 @@ class Honeymaker::Exchanges::GeminiTest < Minitest::Test
 
   def setup
     @exchange = Honeymaker::Exchanges::Gemini.new
+    # Recorded, not slept: the pacing and the backoff are asserted as a sequence.
+    sleeps = @sleeps = []
+    @exchange.define_singleton_method(:sleep) { |seconds| sleeps << seconds }
   end
 
   def test_get_tickers_info_parses_response
-    symbols_body = load_fixture("gemini_symbols.json")
-    detail_body = load_fixture("gemini_symbol_detail.json")
-
-    symbols_response = stub(body: symbols_body)
-    detail_response = stub(body: detail_body)
-    connection = stub
-    connection.stubs(:get).with("/v1/symbols").returns(symbols_response)
-    connection.stubs(:get).with { |path| path.start_with?("/v1/symbols/details/") }.returns(detail_response)
-    @exchange.instance_variable_set(:@connection, connection)
+    stub_catalogue(load_fixture("gemini_symbols.json"))
 
     result = @exchange.get_tickers_info
 
@@ -38,6 +33,111 @@ class Honeymaker::Exchanges::GeminiTest < Minitest::Test
     assert ticker[:trading_enabled]
   end
 
+  def test_get_tickers_info_paces_every_request
+    stub_catalogue(%w[btcusd ethusd])
+
+    assert @exchange.get_tickers_info.success?
+    assert_equal [0.5, 0.5, 0.5], @sleeps
+  end
+
+  def test_get_tickers_info_retries_a_dropped_detail_request
+    connection = stub_catalogue(%w[btcusd ethusd])
+    connection.stubs(:get).with("/v1/symbols/details/ethusd")
+              .raises(Faraday::ConnectionFailed, "end of file reached")
+              .then.returns(stub(body: detail_for("ethusd")))
+
+    result = @exchange.get_tickers_info
+
+    assert result.success?
+    assert_equal 2, result.data.size
+    assert_equal [0.5, 0.5, 0.5, 2, 0.5], @sleeps
+  end
+
+  def test_get_tickers_info_retries_the_symbols_request
+    connection = stub_catalogue(%w[btcusd])
+    connection.stubs(:get).with("/v1/symbols")
+              .raises(Faraday::TooManyRequestsError, "429")
+              .then.returns(stub(body: %w[btcusd]))
+
+    result = @exchange.get_tickers_info
+
+    assert result.success?
+    assert_equal 1, result.data.size
+  end
+
+  def test_get_tickers_info_retries_every_transient_error_class
+    Honeymaker::Exchanges::Gemini::TRANSIENT_ERRORS.each do |error_class|
+      setup
+      connection = stub_catalogue(%w[btcusd])
+      connection.stubs(:get).with("/v1/symbols/details/btcusd")
+                .raises(error_class, "transient").then.returns(detail_response)
+
+      assert @exchange.get_tickers_info.success?, "#{error_class} should be retried"
+    end
+  end
+
+  # All or nothing: data-api reads a pair missing from the catalogue as delisted, so a symbol that
+  # keeps failing must fail the whole catalogue, and nothing after it is fetched.
+  def test_get_tickers_info_fails_whole_catalogue_when_a_symbol_keeps_failing
+    connection = stub_catalogue(%w[btcusd ethusd solusd])
+    connection.expects(:get).with("/v1/symbols/details/ethusd").times(3)
+              .raises(Faraday::ConnectionFailed, "end of file reached")
+    connection.expects(:get).with("/v1/symbols/details/solusd").never
+
+    result = @exchange.get_tickers_info
+
+    assert result.failure?
+    refute_kind_of Array, result.data, "no partial catalogue"
+    assert_equal ["end of file reached"], result.errors
+    assert_equal [0.5, 0.5, 0.5, 2, 0.5, 4, 0.5], @sleeps
+  end
+
+  def test_get_tickers_info_does_not_retry_a_non_transient_error
+    connection = stub_catalogue(%w[btcusd])
+    connection.expects(:get).with("/v1/symbols/details/btcusd").once
+              .raises(Faraday::ResourceNotFound, "404")
+
+    assert @exchange.get_tickers_info.failure?
+  end
+
+  # Gemini lists perpetual swaps in /v1/symbols with the same base and quote as the spot pair
+  # (BTCGUSDPERP is BTC/GUSD). They are not spot instruments, and would take the spot pair's place.
+  def test_get_tickers_info_keeps_only_spot_instruments
+    connection = stub_catalogue(%w[btcusd btcusdperp])
+    connection.stubs(:get).with("/v1/symbols/details/btcusdperp")
+              .returns(stub(body: detail_body.merge("symbol" => "BTCUSDPERP", "product_type" => "swap")))
+
+    result = @exchange.get_tickers_info
+
+    assert result.success?
+    assert_equal %w[BTCUSD], result.data.map { |t| t[:ticker] }
+  end
+
+  # An unclassified instrument is not assumed to be spot: the whole catalogue fails, and callers keep
+  # the one they have.
+  def test_get_tickers_info_fails_when_a_symbol_has_no_product_type
+    connection = stub_catalogue(%w[btcusd ethusd])
+    connection.stubs(:get).with("/v1/symbols/details/ethusd")
+              .returns(stub(body: detail_body.except("product_type").merge("symbol" => "ETHUSD")))
+
+    result = @exchange.get_tickers_info
+
+    assert result.failure?
+    assert_nil result.data
+    assert_match(/ethusd/, result.errors.first)
+  end
+
+  def test_get_tickers_info_fails_when_two_instruments_claim_one_pair
+    connection = stub_catalogue(%w[btcusd btcusd2])
+    connection.stubs(:get).with("/v1/symbols/details/btcusd2")
+              .returns(stub(body: detail_body.merge("symbol" => "BTCUSD2")))
+
+    result = @exchange.get_tickers_info
+
+    assert result.failure?
+    assert_match(%r{BTC/USD}, result.errors.first)
+  end
+
   def test_get_bid_ask_parses_response
     body = load_fixture("gemini_pubticker.json")
     stub_connection(body)
@@ -51,6 +151,31 @@ class Honeymaker::Exchanges::GeminiTest < Minitest::Test
 
   private
 
+  def detail_body
+    load_fixture("gemini_symbol_detail.json")
+  end
+
+  def detail_response
+    stub(body: detail_body)
+  end
+
+  # Every symbol resolves to the one detail fixture; a test overrides a path to make it fail.
+  # Each symbol answers with the fixture's details for its own pair ("ethusd" is ETH/USD), since a
+  # catalogue may not hold two instruments for one pair.
+  def stub_catalogue(symbols)
+    connection = stub
+    connection.stubs(:get).with("/v1/symbols").returns(stub(body: symbols))
+    symbols.each do |symbol|
+      connection.stubs(:get).with("/v1/symbols/details/#{symbol}").returns(stub(body: detail_for(symbol)))
+    end
+    @exchange.instance_variable_set(:@connection, connection)
+    connection
+  end
+
+  def detail_for(symbol)
+    detail_body.merge("symbol" => symbol.upcase, "base_currency" => symbol[0, 3], "quote_currency" => symbol[3..])
+  end
+
   def stub_connection(body)
     response = stub(body: body)
     connection = stub

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: honeymaker
 version: !ruby/object:Gem::Version
-  version: 0.11.5
+  version: 0.11.9
 platform: ruby
 authors:
 - Deltabadger
@@ -170,6 +170,7 @@ files:
 - test/honeymaker/clients/kucoin_client_test.rb
 - test/honeymaker/clients/mexc_client_test.rb
 - test/honeymaker/clients/validation_test.rb
+- test/honeymaker/error_chain_test.rb
 - test/honeymaker/exchange_test.rb
 - test/honeymaker/exchanges/binance_test.rb
 - test/honeymaker/exchanges/binance_us_test.rb