buildkite-test_collector 2.0.0.pre → 2.1.0.pre

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: b7fc00254b8a2002e8680ca265b00f5b2700dace5d6948aa56f779102f8ce0c6
-  data.tar.gz: 6c05b872c740262ca0c66f4d6c09b5b253a366466241513b74706c8d0a56328a
+  metadata.gz: e85ba163eccc317f8e03168153e2018d6b3033b760c3479d7e569848dee8be64
+  data.tar.gz: 2ee8f7c0088bd8cf0eff5b94bff12eaf93a5eec5b34e55e25f4bc31d130dbb53
 SHA512:
-  metadata.gz: 2f646c1a4564960ba78494efef9ec64fa43eb9a4107d7c004884d977649d5cdf07aa19abec49b887d046d1c7a15ec7b61afbde60f4b12769c77f7578ba55df8e
-  data.tar.gz: b80f9fd21f045f396bceea9af860e471191669dc80b1d3e57ae38c5d1b7dcebe3fdfc1646774af043d6b8f243cd7335c9b8f044aff9232146e3c0a4dad8a58d8
+  metadata.gz: 302e0420cf87e321faaaa4cf7843d322d1b9589a31411e4e7239c781f6176ab7d2a8ff2c0d3650912bccd0f863946d8815d7f0667e1cf132497b35410dcfa247
+  data.tar.gz: ff0a31165893a7368465be84a8ba8fbc6f863198a3b8d8965cee9941a29b785a6c547eb70cfa6c6e1283d4378970c0e217dfff87b657cc91837736ccf6c7a978

data/CHANGELOG.md

@@ -1,9 +1,13 @@
 # CHANGELOG
 
+## v2.1.0.pre
+- Minitest plugin to use HTTP Upload API instead of websocket connection to send test data #178 #179 - @niceking
+
 ## v2.0.0.pre
 
 - Major change: RSpec plugin to use HTTP Upload API instead of websocket connection to send test data #174 #175 - @niceking
 - `identifier` field removed from trace #176 - @amybiyuliu
+- Only warn on EOF errors and also catch SSLErrors #160 - @gchan
 
 ## v1.5.0
 

data/Gemfile.lock

@@ -1,14 +1,14 @@
 PATH
   remote: .
   specs:
-    buildkite-test_collector (2.0.0.pre)
+    buildkite-test_collector (2.1.0.pre)
       activesupport (>= 4.2)
       websocket (~> 1.2)
 
 GEM
   remote: https://rubygems.org/
   specs:
-    activesupport (7.0.4.2)
+    activesupport (7.0.4.3)
       concurrent-ruby (~> 1.0, >= 1.0.2)
       i18n (>= 1.6, < 2)
       minitest (>= 5.1)

data/README.md

@@ -89,10 +89,6 @@ BUILDKITE_ANALYTICS_EXECUTION_NAME_PREFIX
 BUILDKITE_ANALYTICS_EXECUTION_NAME_SUFFIX
 ```
 
-## 🔍 Debugging
-
-To enable debugging output, set the `BUILDKITE_ANALYTICS_DEBUG_ENABLED` environment variable to `true`.
-
 ## 🔜 Roadmap
 
 See the [GitHub 'enhancement' issues](https://github.com/buildkite/test-collector-ruby/issues?q=is%3Aissue+is%3Aopen+label%3Aenhancement) for planned features. Pull requests are always welcome, and we’ll give you feedback and guidance if you choose to contribute 💚

data/lib/buildkite/test_collector/ci.rb

@@ -34,7 +34,6 @@ class Buildkite::TestCollector::CI
       "number" => ENV["BUILDKITE_ANALYTICS_NUMBER"],
       "job_id" => ENV["BUILDKITE_ANALYTICS_JOB_ID"],
       "message" => ENV["BUILDKITE_ANALYTICS_MESSAGE"],
-      "debug" => ENV["BUILDKITE_ANALYTICS_DEBUG_ENABLED"],
       "execution_name_prefix" => ENV["BUILDKITE_ANALYTICS_EXECUTION_NAME_PREFIX"],
       "execution_name_suffix" => ENV["BUILDKITE_ANALYTICS_EXECUTION_NAME_SUFFIX"],
       "version" => Buildkite::TestCollector::VERSION,

data/lib/buildkite/test_collector/library_hooks/minitest.rb

@@ -12,4 +12,4 @@ end
 
 Buildkite::TestCollector.enable_tracing!
 
-Buildkite::TestCollector.safe { Buildkite::TestCollector::Uploader.configure }
+Buildkite::TestCollector.session = Buildkite::TestCollector::Session.new

data/lib/buildkite/test_collector/minitest_plugin/reporter.rb

@@ -13,7 +13,7 @@ module Buildkite::TestCollector::MinitestPlugin
 
       if Buildkite::TestCollector.uploader
         if trace = Buildkite::TestCollector.uploader.traces[result.source_location]
-          Buildkite::TestCollector.session&.write_result(trace)
+          Buildkite::TestCollector.session.add_example_to_send_queue(result.source_location)
         end
       end
     end
@@ -21,16 +21,8 @@ module Buildkite::TestCollector::MinitestPlugin
     def report
       super
 
-      if Buildkite::TestCollector.session.present?
-        examples_count = {
-          examples: count,
-          failed: failures,
-          pending: skips,
-          errors_outside_examples: 0, # Minitest does not report this
-        }
-
-        Buildkite::TestCollector.session.close(examples_count)
-      end
+      Buildkite::TestCollector.session.send_remaining_data
+      Buildkite::TestCollector.session.close
     end
   end
 end

data/lib/buildkite/test_collector/uploader.rb

@@ -27,40 +27,6 @@ module Buildkite::TestCollector
       EOFError
     ]
 
-    def self.configure
-      Buildkite::TestCollector.logger.debug("hello from main thread")
-
-      if Buildkite::TestCollector.api_token
-        http = Buildkite::TestCollector::HTTPClient.new(Buildkite::TestCollector.url)
-
-        response = begin
-          http.post
-        rescue *Buildkite::TestCollector::Uploader::REQUEST_EXCEPTIONS => e
-          Buildkite::TestCollector.logger.error "Buildkite Test Analytics: Error communicating with the server: #{e.message}"
-        end
-
-        return unless response
-
-        case response.code
-        when "401"
-          Buildkite::TestCollector.logger.info "Buildkite Test Analytics: Invalid Suite API key. Please double check your Suite API key."
-        when "200"
-          json = JSON.parse(response.body)
-
-          if (socket_url = json["cable"]) && (channel = json["channel"])
-            Buildkite::TestCollector.session = Buildkite::TestCollector::SocketSession.new(socket_url, http.authorization_header, channel)
-          end
-        else
-          request_id = response.to_hash["x-request-id"]
-          Buildkite::TestCollector.logger.info "buildkite-test_collector could not establish an initial connection with Buildkite. You may be missing some data for this test suite, please contact support with request ID #{request_id}."
-        end
-      else
-        if !!ENV["BUILDKITE_BUILD_ID"]
-          Buildkite::TestCollector.logger.info "Buildkite Test Analytics: No Suite API key provided. You can get the API key from your Suite settings page."
-        end
-      end
-    end
-
     def self.tracer
       Thread.current[:_buildkite_tracer]
     end

data/lib/buildkite/test_collector/version.rb

@@ -2,7 +2,7 @@
 
 module Buildkite
   module TestCollector
-    VERSION = "2.0.0.pre"
+    VERSION = "2.1.0.pre"
     NAME = "buildkite-test_collector"
   end
 end

data/lib/buildkite/test_collector.rb

@@ -22,15 +22,12 @@ require "active_support/notifications"
 
 require_relative "test_collector/version"
 require_relative "test_collector/error"
-require_relative "test_collector/logger"
 require_relative "test_collector/ci"
 require_relative "test_collector/http_client"
 require_relative "test_collector/uploader"
 require_relative "test_collector/network"
 require_relative "test_collector/object"
 require_relative "test_collector/tracer"
-require_relative "test_collector/socket_connection"
-require_relative "test_collector/socket_session"
 require_relative "test_collector/session"
 
 module Buildkite
@@ -43,17 +40,15 @@ module Buildkite
       attr_accessor :url
       attr_accessor :uploader
       attr_accessor :session
-      attr_accessor :debug_enabled
       attr_accessor :tracing_enabled
       attr_accessor :artifact_path
       attr_accessor :env
       attr_accessor :batch_size
     end
 
-    def self.configure(hook:, token: nil, url: nil, debug_enabled: false, tracing_enabled: true, artifact_path: nil, env: {})
+    def self.configure(hook:, token: nil, url: nil, tracing_enabled: true, artifact_path: nil, env: {})
       self.api_token = (token || ENV["BUILDKITE_ANALYTICS_TOKEN"])&.strip
       self.url = url || DEFAULT_URL
-      self.debug_enabled = debug_enabled || !!(ENV["BUILDKITE_ANALYTICS_DEBUG_ENABLED"])
       self.tracing_enabled = tracing_enabled
       self.artifact_path = artifact_path
       self.env = env
@@ -74,30 +69,6 @@ module Buildkite
       tracer&.leave
     end
 
-    def self.log_formatter
-      @log_formatter ||= Buildkite::TestCollector::Logger::Formatter.new
-    end
-
-    def self.log_formatter=(log_formatter)
-      @log_formatter = log_formatter
-      logger.formatter = log_formatter
-    end
-
-    def self.logger=(logger)
-      @logger = logger
-    end
-
-    def self.logger
-      return @logger if defined?(@logger)
-
-      debug_mode = ENV.fetch("BUILDKITE_ANALYTICS_DEBUG_ENABLED") do
-        $DEBUG
-      end
-
-      level = !!debug_mode ? ::Logger::DEBUG : ::Logger::WARN
-      @logger ||= Buildkite::TestCollector::Logger.new($stderr, level: level)
-    end
-
     def self.enable_tracing!
       return unless self.tracing_enabled
 
@@ -108,12 +79,5 @@ module Buildkite
         Buildkite::TestCollector::Uploader.tracer&.backfill(:sql, finish - start, **{ query: payload[:sql] })
       end
     end
-
-    def self.safe(&block)
-      block.call
-    rescue StandardError => e
-      logger.error("Buildkite::TestCollector received exception: #{e}")
-      logger.error("Backtrace:\n#{e.backtrace.join("\n")}")
-    end
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: buildkite-test_collector
 version: !ruby/object:Gem::Version
-  version: 2.0.0.pre
+  version: 2.1.0.pre
 platform: ruby
 authors:
 - Buildkite
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2023-03-07 00:00:00.000000000 Z
+date: 2023-03-30 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activesupport
@@ -94,7 +94,6 @@ files:
 - lib/buildkite/test_collector/http_client.rb
 - lib/buildkite/test_collector/library_hooks/minitest.rb
 - lib/buildkite/test_collector/library_hooks/rspec.rb
-- lib/buildkite/test_collector/logger.rb
 - lib/buildkite/test_collector/minitest_plugin.rb
 - lib/buildkite/test_collector/minitest_plugin/reporter.rb
 - lib/buildkite/test_collector/minitest_plugin/trace.rb
@@ -103,8 +102,6 @@ files:
 - lib/buildkite/test_collector/rspec_plugin/reporter.rb
 - lib/buildkite/test_collector/rspec_plugin/trace.rb
 - lib/buildkite/test_collector/session.rb
-- lib/buildkite/test_collector/socket_connection.rb
-- lib/buildkite/test_collector/socket_session.rb
 - lib/buildkite/test_collector/tracer.rb
 - lib/buildkite/test_collector/uploader.rb
 - lib/buildkite/test_collector/version.rb

data/lib/buildkite/test_collector/logger.rb

@@ -1,16 +0,0 @@
-# frozen_string_literal: true
-
-module Buildkite::TestCollector
-  class Logger < ::Logger
-    class Formatter < ::Logger::Formatter
-      def call(severity, time, _program, message)
-        "#{time.utc.iso8601(9)} pid=#{::Process.pid} tid=#{::Thread.current.object_id} #{severity}: #{message}\n"
-      end
-    end
-
-    def initialize(*args, **kwargs)
-      super
-      self.formatter = Buildkite::TestCollector.log_formatter
-    end
-  end
-end

data/lib/buildkite/test_collector/socket_connection.rb

@@ -1,156 +0,0 @@
-# frozen_string_literal: true
-
-module Buildkite::TestCollector
-  class SocketConnection
-    class HandshakeError < StandardError; end
-    class SocketError < StandardError; end
-
-    def initialize(session, url, headers)
-      uri = URI.parse(url)
-      @session = session
-      protocol = "http"
-
-      begin
-        socket = TCPSocket.new(uri.host, uri.port || (uri.scheme == "wss" ? 443 : 80))
-
-        if uri.scheme == "wss"
-          ctx = OpenSSL::SSL::SSLContext.new
-          protocol = "https"
-
-          ctx.min_version = :TLS1_2
-          ctx.verify_mode = OpenSSL::SSL::VERIFY_PEER
-          ctx.cert_store = OpenSSL::X509::Store.new.tap(&:set_default_paths)
-
-          socket = OpenSSL::SSL::SSLSocket.new(socket, ctx)
-          socket.connect
-        end
-      rescue
-        # We are rescuing all here, as there are a range of Errno errors that could be
-        # raised when we fail to establish a TCP connection
-        raise SocketError
-      end
-
-      @socket = socket
-
-      headers = { "Origin" => "#{protocol}://#{uri.host}" }.merge(headers)
-      handshake = WebSocket::Handshake::Client.new(url: url, headers: headers)
-
-      @socket.write handshake.to_s
-
-      until handshake.finished?
-        if byte = @socket.getc
-          handshake << byte
-        end
-      end
-
-      # The errors below are raised when we establish the TCP connection, but get back
-      # an error, i.e. in dev we can still connect to puma-dev while nginx isn't
-      # running, or in prod we can hit a load balancer while app is down
-      unless handshake.valid?
-        case handshake.error
-        when Exception, String
-          raise HandshakeError.new(handshake.error)
-        when nil
-          raise HandshakeError.new("Invalid handshake")
-        else
-          raise HandshakeError.new(handshake.error.inspect)
-        end
-      end
-
-      @version = handshake.version
-
-      # Setting up a new thread that listens on the socket, and processes incoming
-      # comms from the server
-      @read_thread = Thread.new do
-        Buildkite::TestCollector.logger.debug("listening in on socket")
-        frame = WebSocket::Frame::Incoming::Client.new
-
-        while @socket
-          frame << @socket.readpartial(4096)
-
-          while data = frame.next
-            @session.handle(self, data.data)
-          end
-        end
-      # These get re-raise from session, we should fail gracefully
-      rescue *Buildkite::TestCollector::SocketSession::DISCONNECTED_EXCEPTIONS => e
-        Buildkite::TestCollector.logger.error("We could not establish a connection with Buildkite Test Analytics. The error was: #{e.message}. If this is a problem, please contact support.")
-      rescue EOFError, OpenSSL::SSL::SSLError => e
-        # https://github.com/buildkite/test-collector-ruby/pull/147#issuecomment-1250485611
-        raise if e.class == OpenSSL::SSL::SSLError && e.message != "SSL_read: unexpected eof while reading"
-
-        Buildkite::TestCollector.logger.warn("#{e}")
-        if @socket
-          Buildkite::TestCollector.logger.warn("attempting disconnected flow")
-          @session.disconnected(self)
-          disconnect
-        end
-      rescue Errno::ECONNRESET, Errno::ETIMEDOUT => e
-        Buildkite::TestCollector.logger.error("#{e}")
-        if @socket
-          Buildkite::TestCollector.logger.error("attempting disconnected flow")
-          @session.disconnected(self)
-          disconnect
-        end
-      rescue IOError
-        # This is fine to ignore
-        Buildkite::TestCollector.logger.error("IOError")
-      rescue IndexError
-        # I don't like that we're doing this but I think it's the best of the options
-        #
-        # This relates to this issue https://github.com/ruby/openssl/issues/452
-        # A fix for it has been released but the repercussions of overriding
-        # the OpenSSL version in the stdlib seem worse than catching this error here.
-        Buildkite::TestCollector.logger.error("IndexError")
-        if @socket
-          Buildkite::TestCollector.logger.error("attempting disconnected flow")
-          @session.disconnected(self)
-          disconnect
-        end
-      end
-    end
-
-    def transmit(data, type: :text)
-      # this line prevents us from calling disconnect twice
-      return if @socket.nil?
-
-      raw_data = data.to_json
-      frame = WebSocket::Frame::Outgoing::Client.new(data: raw_data, type: :text, version: @version)
-      @socket.write(frame.to_s)
-    rescue Errno::EPIPE, Errno::ECONNRESET, OpenSSL::SSL::SSLError => e
-      return unless @socket
-      return if type == :close
-      Buildkite::TestCollector.logger.error("got #{e}, attempting disconnected flow")
-      @session.disconnected(self)
-      disconnect
-    rescue IndexError
-      # I don't like that we're doing this but I think it's the best of the options
-      #
-      # This relates to this issue https://github.com/ruby/openssl/issues/452
-      # A fix for it has been released but the repercussions of overriding
-      # the OpenSSL version in the stdlib seem worse than catching this error here.
-      Buildkite::TestCollector.logger.error("IndexError")
-      if @socket
-        Buildkite::TestCollector.logger.error("attempting disconnected flow")
-        @session.disconnected(self)
-        disconnect
-      end
-    end
-
-    def close
-      Buildkite::TestCollector.logger.debug("socket close")
-      transmit(nil, type: :close)
-      disconnect
-    end
-
-    private
-
-    def disconnect
-      Buildkite::TestCollector.logger.debug("socket disconnect")
-      socket = @socket
-      @socket = nil
-      socket&.close
-      @read_thread&.join unless @read_thread == Thread.current
-    end
-  end
-end

data/lib/buildkite/test_collector/socket_session.rb

@@ -1,333 +0,0 @@
-# frozen_string_literal: true
-
-module Buildkite::TestCollector
-  class SocketSession
-    # Picked 75 as the magic timeout number as it's longer than the TCP timeout of 60s 🤷‍♀️
-    CONFIRMATION_TIMEOUT = ENV.fetch("BUILDKITE_ANALYTICS_CONFIRMATION_TIMEOUT") { 75 }.to_i
-    MAX_RECONNECTION_ATTEMPTS = ENV.fetch("BUILDKITE_ANALYTICS_RECONNECTION_ATTEMPTS") { 3 }.to_i
-    WAIT_BETWEEN_RECONNECTIONS = ENV.fetch("BUILDKITE_ANALYTICS_RECONNECTION_WAIT") { 5 }.to_i
-
-    # We keep a private reference so that mocking libraries won't break JSON
-    JSON_PARSE = JSON.method(:parse)
-    private_constant :JSON_PARSE
-
-    class RejectedSubscription < StandardError; end
-    class InitialConnectionFailure < StandardError; end
-
-    DISCONNECTED_EXCEPTIONS = [
-      Buildkite::TestCollector::SocketConnection::HandshakeError,
-      Buildkite::TestCollector::TimeoutError,
-      Buildkite::TestCollector::SocketConnection::SocketError,
-      RejectedSubscription,
-      InitialConnectionFailure,
-    ]
-
-    def initialize(url, authorization_header, channel)
-      @establish_subscription_queue = Queue.new
-      @channel = channel
-
-      @unconfirmed_idents = {}
-      @idents_mutex = Mutex.new
-      @send_queue = Queue.new
-      @empty = ConditionVariable.new
-      @closing = false
-      @eot_queued = false
-      @eot_queued_mutex = Mutex.new
-      @reconnection_mutex = Mutex.new
-
-      @url = url
-      @authorization_header = authorization_header
-
-      reconnection_count = 0
-
-      begin
-        reconnection_count += 1
-        connect
-      rescue Buildkite::TestCollector::TimeoutError, InitialConnectionFailure => e
-        Buildkite::TestCollector.logger.warn("buildkite-test_collector could not establish an initial connection with Buildkite due to #{e}. Attempting retry #{reconnection_count} of #{MAX_RECONNECTION_ATTEMPTS}...")
-        if reconnection_count > MAX_RECONNECTION_ATTEMPTS
-          Buildkite::TestCollector.logger.error "buildkite-test_collector could not establish an initial connection with Buildkite due to #{e.message} after #{MAX_RECONNECTION_ATTEMPTS} attempts. You may be missing some data for this test suite, please contact support if this issue persists."
-        else
-          sleep(WAIT_BETWEEN_RECONNECTIONS)
-          Buildkite::TestCollector.logger.warn("retrying reconnection")
-          retry
-        end
-      end
-      init_write_thread
-    end
-
-    def disconnected(connection)
-      @reconnection_mutex.synchronize do
-        # When the first thread detects a disconnection, it calls the disconnect method
-        # with the current connection. This thread grabs the reconnection mutex and does the
-        # reconnection, which then updates the value of @connection.
-        #
-        # At some point in that process, the second thread would have detected the
-        # disconnection too, and it also calls it with the current connection. However, the
-        # second thread can't run the reconnection code because of the mutex. By the
-        # time the mutex is released, the value of @connection has been refreshed, and so
-        # the second thread returns early and does not reattempt the reconnection.
-        return unless connection == @connection
-        Buildkite::TestCollector.logger.debug("starting reconnection")
-
-        reconnection_count = 0
-
-        begin
-          reconnection_count += 1
-          connect
-          init_write_thread
-        rescue *DISCONNECTED_EXCEPTIONS => e
-          Buildkite::TestCollector.logger.warn("failed reconnection attempt #{reconnection_count} due to #{e}")
-          if reconnection_count > MAX_RECONNECTION_ATTEMPTS
-            Buildkite::TestCollector.logger.error "buildkite-test_collector experienced a disconnection and could not reconnect to Buildkite due to #{e.message}. Please contact support."
-            raise e
-          else
-            sleep(WAIT_BETWEEN_RECONNECTIONS)
-            Buildkite::TestCollector.logger.warn("retrying reconnection")
-            retry
-          end
-        end
-      end
-      retransmit
-    end
-
-    def close(examples_count)
-      @closing = true
-      @examples_count = examples_count
-      Buildkite::TestCollector.logger.debug("closing socket connection")
-
-      # Because the server only sends us confirmations after every 10mb of
-      # data it uploads to S3, we'll never get confirmation of the
-      # identifiers of the last upload part unless we send an explicit finish,
-      # to which the server will respond with the last bits of data
-      send_eot
-
-      # After EOT, we wait for 75 seconds for the send queue to be drained and for the
-      # server to confirm the last idents. If everything has already been confirmed we can
-      # proceed without waiting.
-      @idents_mutex.synchronize do
-        if @unconfirmed_idents.any?
-          Buildkite::TestCollector.logger.debug "Waiting for Buildkite Test Analytics to send results..."
-          Buildkite::TestCollector.logger.debug("waiting for last confirm")
-
-          @empty.wait(@idents_mutex, CONFIRMATION_TIMEOUT)
-        end
-      end
-
-      # Then we always disconnect cos we can't wait forever? 🤷‍♀️
-      @connection.close
-      # We kill the write thread cos it's got a while loop in it, so it won't finish otherwise
-      @write_thread&.kill
-
-      Buildkite::TestCollector.logger.info "Buildkite Test Analytics completed"
-      Buildkite::TestCollector.logger.debug("socket connection closed")
-    end
-
-    def handle(_connection, data)
-      data = JSON_PARSE.call(data)
-      case data["type"]
-      when "ping"
-        # In absence of other message, the server sends us a ping every 3 seconds
-        # We are currently not doing anything with these
-        Buildkite::TestCollector.logger.debug("received ping")
-      when "welcome", "confirm_subscription"
-        # Push these two messages onto the queue, so that we block on waiting for the
-        # initializing phase to complete
-        @establish_subscription_queue.push(data)
-      Buildkite::TestCollector.logger.debug("received #{data['type']}")
-      when "reject_subscription"
-        Buildkite::TestCollector.logger.debug("received rejected_subscription")
-        raise RejectedSubscription
-      else
-        process_message(data)
-      end
-    end
-
-    def write_result(result)
-      queue_and_track_result(result.id, result.as_hash)
-
-      Buildkite::TestCollector.logger.debug("added #{result.id} to send queue")
-    end
-
-    def unconfirmed_idents_count
-      @idents_mutex.synchronize do
-        @unconfirmed_idents.count
-      end
-    end
-
-    private
-
-    def connect
-      Buildkite::TestCollector.logger.debug("starting socket connection process")
-
-      @connection = SocketConnection.new(self, @url, {
-        "Authorization" => @authorization_header,
-      })
-
-      wait_for_welcome
-
-      @connection.transmit({
-        "command" => "subscribe",
-        "identifier" => @channel
-      })
-
-      wait_for_confirm
-
-      Buildkite::TestCollector.logger.info "Connected to Buildkite Test Analytics!"
-      Buildkite::TestCollector.logger.debug("connected")
-    end
-
-    def init_write_thread
-      # As this method can be called multiple times in the
-      # reconnection process, kill prev write threads (if any) before
-      # setting up the new one
-      @write_thread&.kill
-
-      @write_thread = Thread.new do
-        Buildkite::TestCollector.logger.debug("hello from write thread")
-        # Pretty sure this eternal loop is fine cos the call to queue.pop is blocking
-        loop do
-          data = @send_queue.pop
-          message_type = data["action"]
-
-          if message_type == "end_of_transmission"
-            # Because of the unpredictable sequencing between the test suite finishing
-            # (EOT gets queued) and disconnections happening (retransmit results gets
-            # queued), we don't want to send an EOT before any retransmits are sent.
-            if @send_queue.length > 0
-              @send_queue << data
-              Buildkite::TestCollector.logger.debug("putting eot at back of queue")
-              next
-            end
-            @eot_queued_mutex.synchronize do
-              @eot_queued = false
-            end
-          end
-
-          @connection.transmit({
-            "identifier" => @channel,
-            "command" => "message",
-            "data" => data.to_json
-          })
-
-          if Buildkite::TestCollector.debug_enabled
-            ids = if message_type == "record_results"
-              data["results"].map { |result| result["id"] }
-            end
-            Buildkite::TestCollector.logger.debug("transmitted #{message_type} #{ids}")
-          end
-        end
-      end
-    end
-
-    def pop_with_timeout(message_type)
-      Timeout.timeout(30, Buildkite::TestCollector::TimeoutError, "Timeout: Waited 30 seconds for #{message_type}") do
-        @establish_subscription_queue.pop
-      end
-    end
-
-    def wait_for_welcome
-      welcome = pop_with_timeout("welcome")
-
-      if welcome && welcome != { "type" => "welcome" }
-        raise InitialConnectionFailure.new("Wrong message received, expected a welcome, but received: #{welcome.inspect}")
-      end
-    end
-
-    def wait_for_confirm
-      confirm = pop_with_timeout("confirm")
-
-      if confirm && confirm != { "type" => "confirm_subscription", "identifier" => @channel }
-        raise InitialConnectionFailure.new("Wrong message received, expected a confirm, but received: #{confirm.inspect}")
-      end
-    end
-
-    def queue_and_track_result(ident, result_as_hash)
-      @idents_mutex.synchronize do
-        @unconfirmed_idents[ident] = result_as_hash
-
-        @send_queue << {
-          "action" => "record_results",
-          "results" => [result_as_hash]
-        }
-      end
-    end
-
-    def confirm_idents(idents)
-      retransmit_required = @closing
-
-      @idents_mutex.synchronize do
-        # Remove received idents from unconfirmed_idents
-        idents.each { |key| @unconfirmed_idents.delete(key) }
-
-        Buildkite::TestCollector.logger.debug("received confirm for indentifiers: #{idents}")
-
-        # This @empty ConditionVariable broadcasts every time that @unconfirmed_idents is
-        # empty, which will happen about every 10mb of data as that's when the server
-        # sends back confirmations.
-        #
-        # However, there aren't any threads waiting on this signal until after we
-        # send the EOT message, so the prior broadcasts shouldn't do anything.
-        if @unconfirmed_idents.empty?
-          @empty.broadcast
-
-          retransmit_required = false
-
-          Buildkite::TestCollector.logger.debug("all identifiers have been confirmed")
-        else
-          Buildkite::TestCollector.logger.debug("still waiting on confirm for identifiers: #{@unconfirmed_idents.keys}")
-        end
-      end
-
-      # If we're closing, any unconfirmed results need to be retransmitted.
-      retransmit if retransmit_required
-    end
-
-    def send_eot
-      @eot_queued_mutex.synchronize do
-        return if @eot_queued
-
-        @send_queue << {
-          "action" => "end_of_transmission",
-          "examples_count" => @examples_count.to_json
-        }
-        @eot_queued = true
-
-        Buildkite::TestCollector.logger.debug("added EOT to send queue")
-      end
-    end
-
-    def process_message(data)
-      # Check we're getting the data we expect
-      return unless data["identifier"] == @channel
-
-      case
-      when data["message"].key?("confirm")
-        confirm_idents(data["message"]["confirm"])
-      else
-        # unhandled message
-        Buildkite::TestCollector.logger.debug("received unhandled message #{data["message"]}")
-      end
-    end
-
-    def retransmit
-      @idents_mutex.synchronize do
-        results = @unconfirmed_idents.values
-
-        # queue the contents of the buffer, unless it's empty
-        if results.any?
-          @send_queue << {
-            "action" => "record_results",
-            "results" => results
-          }
-
-          Buildkite::TestCollector.logger.debug("queueing up retransmitted results #{@unconfirmed_idents.keys}")
-        end
-      end
-
-      # if we were disconnected in the closing phase, then resend the EOT
-      # message so the server can persist the last upload part
-      send_eot if @closing
-    end
-  end
-end