ruby-kafka 0.3.17 → 0.3.18.beta1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: ae14c68f2b224bf04659de3a17203e7065d5efd7
-  data.tar.gz: d33dd2594e8159eb23d3a8589b789f2b66c5993b
+  metadata.gz: 80c7dd382316d8fd5465ab7f73a4393cf3ed01cf
+  data.tar.gz: b30842098f9076127c33eb762dffc71424de2866
 SHA512:
-  metadata.gz: 9f2d374b0237fad7d3678f18ee903640a40bc735f995b3138286928398d5d6b595bc3ce395a86d60810934617cdc2c1e207d305c5b245323c9281ffe4bc33bc5
-  data.tar.gz: 0403e6ba029d666660395fc666dc4003195e9aa947b2c44936415394b12abd14946830d4b369ac5587f5d71858f40c6ff0630628c51602603e98f340e065ef36
+  metadata.gz: 90b3ed06f47b6e2b22a7623bcf3825206b7745170207cb9e2226adcc2ee60988769e7ad498a241e30eb0f04dbf3daa56acef4c91c5334b04ded7d1cb429e4866
+  data.tar.gz: 72c20e866cd03e575bbae4d82a86fe56195463412929dbb4656c1cfc16ef4c9f109317897ad7773cc79ccd22da395c440522b174e786f2ff358629c4db897dc8

data/.gitignore

@@ -8,3 +8,4 @@
 /tmp/
 .env
 *.log
+*.swp

data/Gemfile.lock

@@ -1,7 +1,8 @@
 PATH
   remote: .
   specs:
-    ruby-kafka (0.3.15)
+    ruby-kafka (0.3.18.beta1)
+      gssapi (>= 1.2.0)
 
 GEM
   remote: https://rubygems.org/
@@ -23,6 +24,9 @@ GEM
     dogstatsd-ruby (2.1.0)
     dotenv (2.1.0)
     excon (0.54.0)
+    ffi (1.9.18)
+    gssapi (1.2.0)
+      ffi (>= 1.0.1)
     i18n (0.7.0)
     json (1.8.3)
     method_source (0.8.2)
@@ -83,4 +87,4 @@ RUBY VERSION
    ruby 2.2.3p173
 
 BUNDLED WITH
-   1.13.6
+   1.14.6

data/README.md

@@ -33,7 +33,9 @@ Although parts of this library work with Kafka 0.8 – specifically, the Produce
     7. [Monitoring](#monitoring)
         1. [Reporting Metrics to Datadog](#reporting-metrics-to-datadog)
     8. [Understanding Timeouts](#understanding-timeouts)
-    9. [Encryption and Authentication using SSL](#encryption-and-authentication-using-ssl)
+    9. [Security](#security)
+        1. [Encryption and Authentication using SSL](#encryption-and-authentication-using-ssl)
+        2. [Authentication using SASL](#authentication-using-sasl)
 4. [Design](#design)
     1. [Producer Design](#producer-design)
     2. [Asynchronous Producer Design](#asynchronous-producer-design)
@@ -101,7 +103,7 @@ require "kafka"
 kafka = Kafka.new(
   # At least one of these nodes must be available:
   seed_brokers: ["kafka1:9092", "kafka2:9092"],
-  
+
   # Set an optional client id in order to identify the client to Kafka:
   client_id: "my-application",
 )
@@ -198,7 +200,7 @@ These policies can be used alone or in combination.
 producer = kafka.async_producer(
   # Trigger a delivery once 100 messages have been buffered.
   delivery_threshold: 100,
-  
+
   # Trigger a delivery every 30 seconds.
   delivery_interval: 30,
 )
@@ -435,13 +437,13 @@ In your controllers, simply call the producer directly:
 class OrdersController
   def create
     @order = Order.create!(params[:order])
-    
+
     event = {
       order_id: @order.id,
       amount: @order.amount,
       timestamp: Time.now,
     }
-    
+
     $kafka_producer.produce(event.to_json, topic: "order_events")
   end
 end
@@ -449,8 +451,6 @@ end
 
 ### Consuming Messages from Kafka
 
-**Warning:** The Consumer API is still alpha level and will likely change. The consumer code should not be considered stable, as it hasn't been exhaustively tested in production environments yet.
-
 Consuming messages from a Kafka topic is simple:
 
 ```ruby
@@ -501,9 +501,11 @@ Each consumer process will be assigned one or more partitions from each topic th
 
 In order to be able to resume processing after a consumer crashes, each consumer will periodically _checkpoint_ its position within each partition it reads from. Since each partition has a monotonically increasing sequence of message offsets, this works by _committing_ the offset of the last message that was processed in a given partition. Kafka handles these commits and allows another consumer in a group to resume from the last commit when a member crashes or becomes unresponsive.
 
-By default, offsets are committed every 10 seconds. You can increase the frequency, known as the _offset commit interval_, to limit the duration of double-processing scenarios, at the cost of a lower throughput due to the added coordination. If you want to improve throughput, and double-processing is of less concern to you, then you can decrease the frequency.
+By default, offsets are committed every 10 seconds. You can increase the frequency, known as the _offset commit interval_, to limit the duration of double-processing scenarios, at the cost of a lower throughput due to the added coordination. If you want to improve throughput, and double-processing is of less concern to you, then you can decrease the frequency. Set the commit interval to zero in order to disable the timer-based commit trigger entirely.
+
+In addition to the time based trigger it's possible to trigger checkpointing in response to _n_ messages having been processed, known as the _offset commit threshold_. This puts a bound on the number of messages that can be double-processed before the problem is detected. Setting this to 1 will cause an offset commit to take place every time a message has been processed. By default this trigger is disabled (set to zero).
 
-In addition to the time based trigger it's possible to trigger checkpointing in response to _n_ messages having been processed, known as the _offset commit threshold_. This puts a bound on the number of messages that can be double-processed before the problem is detected. Setting this to 1 will cause an offset commit to take place every time a message has been processed. By default this trigger is disabled.
+It is possible to trigger an immediate offset commit by calling `Consumer#commit_offsets`. This blocks the caller until the Kafka cluster has acknowledged the commit.
 
 Stale offsets are periodically purged by the broker. The broker setting `offsets.retention.minutes` controls the retention window for committed offsets, and defaults to 1 day. The length of the retention window, known as _offset retention time_, can be changed for the consumer.
 
@@ -524,6 +526,46 @@ consumer = kafka.consumer(
 )
 ```
 
+For some use cases it may be necessary to control when messages are marked as processed. Note that since only the consumer position within each partition can be saved, marking a message as processed implies that all messages in the partition with a lower offset should also be considered as having been processed.
+
+The method `Consumer#mark_message_as_processed` marks a message (and all those that precede it in a partition) as having been processed. This is an advanced API that you should only use if you know what you're doing.
+
+```ruby
+# Manually controlling checkpointing:
+
+# Typically you want to use this API in order to buffer messages until some
+# special "commit" message is received, e.g. in order to group together
+# transactions consisting of several items.
+buffer = []
+
+# Messages will not be marked as processed automatically. If you shut down the
+# consumer without calling `#mark_message_as_processed` first, the consumer will
+# not resume where you left off!
+consumer.each_message(automatically_mark_as_processed: false) do |message|
+  # Our messages are JSON with a `type` field and other stuff.
+  event = JSON.parse(message.value)
+
+  case event.fetch("type")
+  when "add_to_cart"
+    buffer << event
+  when "complete_purchase"
+    # We've received all the messages we need, time to save the transaction.
+    save_transaction(buffer)
+
+    # Now we can set the checkpoint by marking the last message as processed.
+    consumer.mark_message_as_processed(message)
+
+    # We can optionally trigger an immediate, blocking offset commit in order
+    # to minimize the risk of crashing before the automatic triggers have
+    # kicked in.
+    consumer.commit_offsets
+
+    # Make the buffer ready for the next transaction.
+    buffer.clear
+  end
+end
+```
+
 
 #### Topic Subscriptions
 
@@ -614,9 +656,9 @@ If you want to have at most one second of latency, set `max_wait_time: 1`.
 
 ### Thread Safety
 
-You typically don't want to share a Kafka client between threads, since the network communication is not synchronized. Furthermore, you should avoid using threads in a consumer unless you're very careful about waiting for all work to complete before returning from the `#each_message` or `#each_batch` block. This is because _checkpointing_ assumes that returning from the block means that the messages that have been yielded have been successfully processed.
+You typically don't want to share a Kafka client object between threads, since the network communication is not synchronized. Furthermore, you should avoid using threads in a consumer unless you're very careful about waiting for all work to complete before returning from the `#each_message` or `#each_batch` block. This is because _checkpointing_ assumes that returning from the block means that the messages that have been yielded have been successfully processed.
 
-You should also avoid sharing a synchronous producer between threads, as the internal buffers are not thread safe. However, the _asynchronous_ producer should be safe to use in a multi-threaded environment.
+You should also avoid sharing a synchronous producer between threads, as the internal buffers are not thread safe. However, the _asynchronous_ producer should be safe to use in a multi-threaded environment. This is because producers, when instantiated, get their own copy of any non-thread-safe data such as network sockets. Furthermore, the asynchronous producer has been designed in such a way to only a single background thread operates on this data while any foreground thread with a reference to the producer object can only send messages to that background thread over a safe queue. Therefore it is safe to share an async producer object between many threads.
 
 ### Logging
 
@@ -721,11 +763,13 @@ When sending many messages, it's likely that the client needs to send some messa
 
 Make sure your application can survive being blocked for so long.
 
-### Encryption and Authentication using SSL
+### Security
+
+#### Encryption and Authentication using SSL
 
 By default, communication between Kafka clients and brokers is unencrypted and unauthenticated. Kafka 0.9 added optional support for [encryption and client authentication and authorization](http://kafka.apache.org/documentation.html#security_ssl). There are two layers of security made possible by this:
 
-#### Encryption of Communication
+##### Encryption of Communication
 
 By enabling SSL encryption you can have some confidence that messages can be sent to Kafka over an untrusted network without being intercepted.
 
@@ -740,7 +784,7 @@ kafka = Kafka.new(
 
 Without passing the CA certificate to the client it would be impossible to protect against [man-in-the-middle attacks](https://en.wikipedia.org/wiki/Man-in-the-middle_attack).
 
-#### Client Authentication
+##### Client Authentication
 
 In order to authenticate the client to the cluster, you need to pass in a certificate and key created for the client and trusted by the brokers.
 
@@ -755,6 +799,24 @@ kafka = Kafka.new(
 
 Once client authentication is set up, it is possible to configure the Kafka cluster to [authorize client requests](http://kafka.apache.org/documentation.html#security_authz).
 
+##### Using JKS Certificates
+
+Typically, Kafka certificates come in the JKS format, which isn't supported by ruby-kafka. There's [a wiki page](https://github.com/zendesk/ruby-kafka/wiki/Creating-X509-certificates-from-JKS-format) that describes how to generate valid X509 certificates from JKS certificates.
+
+#### Authentication using SASL
+
+Kafka has support for using SASL to authenticate clients. Currently only the GSSAPI mechanism is supported by ruby-kafka.
+
+In order to authenticate using SASL, set your principal and optionally your keytab when initializing the Kafka client:
+
+```ruby
+kafka = Kafka.new(
+  sasl_gssapi_principal: 'kafka/kafka.example.com@EXAMPLE.COM',
+  sasl_gssapi_keytab: '/etc/keytabs/kafka.keytab',
+  # ...
+)
+```
+
 ## Design
 
 The library has been designed as a layered system, with each layer having a clear responsibility:

data/lib/kafka.rb

@@ -79,6 +79,7 @@ module Kafka
   class NotCoordinatorForGroup < ProtocolError
   end
 
+  # 17
   # For a request which attempts to access an invalid topic (e.g. one which has
   # an illegal name), or if an attempt is made to write to an internal topic
   # (such as the consumer offsets topic).
@@ -90,37 +91,105 @@ module Kafka
   class RecordListTooLarge < ProtocolError
   end
 
+  # 19
   # Returned from a produce request when the number of in-sync replicas is
   # lower than the configured minimum and requiredAcks is -1.
   class NotEnoughReplicas < ProtocolError
   end
 
+  # 20
   # Returned from a produce request when the message was written to the log,
   # but with fewer in-sync replicas than required.
   class NotEnoughReplicasAfterAppend < ProtocolError
   end
 
+  # 21
   # Returned from a produce request if the requested requiredAcks is invalid
   # (anything other than -1, 1, or 0).
   class InvalidRequiredAcks < ProtocolError
   end
 
+  # 9
   # Raised if a replica is expected on a broker, but is not. Can be safely ignored.
   class ReplicaNotAvailable < ProtocolError
   end
 
+  #
   class UnknownMemberId < ProtocolError
   end
 
+  # 27
   class RebalanceInProgress < ProtocolError
   end
 
+  # 22
   class IllegalGeneration < ProtocolError
   end
 
+  # 26
   class InvalidSessionTimeout < ProtocolError
   end
 
+  # 28
+  class InvalidCommitOffsetSize < ProtocolError
+  end
+
+  # 29
+  class TopicAuthorizationCode < ProtocolError
+  end
+
+  # 30
+  class GroupAuthorizationCode < ProtocolError
+  end
+
+  # 31
+  class ClusterAuthorizationCode < ProtocolError
+  end
+
+  # 32
+  class InvalidTimestamp < ProtocolError
+  end
+
+  # 33
+  class UnsupportedSaslMechanism < ProtocolError
+  end
+
+  # 34
+  class InvalidSaslState < ProtocolError
+  end
+
+  # 35
+  class UnsupportedVersion < ProtocolError
+  end
+
+  # 36
+  class TopicAlreadyExists < Error
+  end
+
+  # 37
+  class InvalidPartitions < Error
+  end
+
+  # 38
+  class InvalidReplicationFactor < Error
+  end
+
+  # 39
+  class InvalidReplicaAssignment < Error
+  end
+
+  # 40
+  class InvalidConfig < Error
+  end
+
+  # 41
+  class NotController < Error
+  end
+
+  # 42
+  class InvalidRequest < Error
+  end
+
   # Raised when there's a network connection error.
   class ConnectionError < Error
   end
@@ -142,6 +211,9 @@ module Kafka
   class FetchError < Error
   end
 
+  class NoPartitionsAssignedError < Error
+  end
+
   # Initializes a new Kafka client.
   #
   # @see Client#initialize

data/lib/kafka/broker.rb

@@ -40,6 +40,22 @@ module Kafka
       @connection.send_request(request)
     end
 
+    # Fetches messages asynchronously.
+    #
+    # The fetch request is sent to the broker, but the response is not read.
+    # This allows the broker to process the request, wait for new messages,
+    # and send a response without the client having to wait. In order to
+    # read the response, call `#call` on the returned object. This will
+    # block the caller until the response is available.
+    #
+    # @param (see Kafka::Protocol::FetchRequest#initialize)
+    # @return [Kafka::AsyncResponse]
+    def fetch_messages_async(**options)
+      request = Protocol::FetchRequest.new(**options)
+
+      @connection.send_async_request(request)
+    end
+
     # Lists the offset of the specified topics and partitions.
     #
     # @param (see Kafka::Protocol::ListOffsetRequest#initialize)
@@ -101,5 +117,11 @@ module Kafka
 
       @connection.send_request(request)
     end
+
+    def sasl_handshake(**options)
+      request = Protocol::SaslHandshakeRequest(**options)
+
+      @connection.send_request(request)
+    end
   end
 end

data/lib/kafka/client.rb

@@ -40,8 +40,14 @@ module Kafka
     # @param ssl_client_cert_key [String, nil] a PEM encoded client cert key to use with an
     #   SSL connection. Must be used in combination with ssl_client_cert.
     #
+    # @param sasl_gssapi_principal [String, nil] a KRB5 principal
+    #
+    # @param sasl_gssapi_keytab [String, nil] a KRB5 keytab filepath
+    #
     # @return [Client]
-    def initialize(seed_brokers:, client_id: "ruby-kafka", logger: nil, connect_timeout: nil, socket_timeout: nil, ssl_ca_cert: nil, ssl_client_cert: nil, ssl_client_cert_key: nil)
+    def initialize(seed_brokers:, client_id: "ruby-kafka", logger: nil, connect_timeout: nil, socket_timeout: nil,
+                   ssl_ca_cert: nil, ssl_client_cert: nil, ssl_client_cert_key: nil,
+                   sasl_gssapi_principal: nil, sasl_gssapi_keytab: nil)
       @logger = logger || Logger.new(nil)
       @instrumenter = Instrumenter.new(client_id: client_id)
       @seed_brokers = normalize_seed_brokers(seed_brokers)
@@ -55,6 +61,8 @@ module Kafka
         ssl_context: ssl_context,
         logger: @logger,
         instrumenter: @instrumenter,
+        sasl_gssapi_principal: sasl_gssapi_principal,
+        sasl_gssapi_keytab: sasl_gssapi_keytab
       )
 
       @cluster = initialize_cluster
@@ -414,6 +422,26 @@ module Kafka
       @cluster.resolve_offset(topic, partition, :latest) - 1
     end
 
+
+    # Retrieve the offset of the last message in each partition of the specified topics.
+    #
+    # @param topics [Array<String>] topic names.
+    # @return [Hash<String, Hash<Integer, Integer>>]
+    # @example
+    #   last_offsets_for('topic-1', 'topic-2') # =>
+    #   # {
+    #   #   'topic-1' => { 0 => 100, 1 => 100 },
+    #   #   'topic-2' => { 0 => 100, 1 => 100 }
+    #   # }
+    def last_offsets_for(*topics)
+      @cluster.add_target_topics(topics)
+      topics.map {|topic|
+        partition_ids = @cluster.partitions_for(topic).collect(&:partition_id)
+        partition_offsets = @cluster.resolve_offsets(topic, partition_ids, :latest)
+        [topic, partition_offsets.collect { |k, v| [k, v - 1] }.to_h]
+      }.to_h
+    end
+
     # Closes all connections to the Kafka brokers and frees up used resources.
     #
     # @return [nil]

data/lib/kafka/cluster.rb

@@ -157,6 +157,9 @@ module Kafka
       end
 
       offsets
+    rescue Kafka::ProtocolError
+      mark_as_stale!
+      raise
     end
 
     def resolve_offset(topic, partition, offset)
@@ -190,7 +193,7 @@ module Kafka
     # @raise [ConnectionError] if none of the nodes in `seed_brokers` are available.
     # @return [Protocol::MetadataResponse] the cluster metadata.
     def fetch_cluster_info
-      @seed_brokers.each do |node|
+      @seed_brokers.shuffle.each do |node|
         @logger.info "Fetching cluster metadata from #{node}"
 
         begin

data/lib/kafka/connection.rb

@@ -2,11 +2,41 @@ require "stringio"
 require "kafka/socket_with_timeout"
 require "kafka/ssl_socket_with_timeout"
 require "kafka/protocol/request_message"
+require "kafka/protocol/null_response"
 require "kafka/protocol/encoder"
 require "kafka/protocol/decoder"
 
 module Kafka
 
+  # An asynchronous response object allows us to deliver a response at some
+  # later point in time.
+  #
+  # When instantiating an AsyncResponse, you provide a response decoder and
+  # a block that will force the caller to wait until a response is available.
+  class AsyncResponse
+    # Use a custom "nil" value so that nil can be an actual value.
+    MISSING = Object.new
+
+    def initialize(decoder, &block)
+      @decoder = decoder
+      @block = block
+      @response = MISSING
+    end
+
+    # Block until a response is available.
+    def call
+      @block.call if @response == MISSING
+      @response
+    end
+
+    # Deliver the response data.
+    #
+    # After calling this, `#call` will returned the decoded response.
+    def deliver(data)
+      @response = @decoder.decode(data)
+    end
+  end
+
   # A connection to a single Kafka broker.
   #
   # Usually you'll need a separate connection to each broker in a cluster, since most
@@ -28,6 +58,9 @@ module Kafka
     SOCKET_TIMEOUT = 10
     CONNECT_TIMEOUT = 10
 
+    attr_reader :encoder
+    attr_reader :decoder
+
     # Opens a connection to a Kafka broker.
     #
     # @param host [String] the hostname of the broker.
@@ -75,6 +108,18 @@ module Kafka
     #
     # @return [Object] the response.
     def send_request(request)
+      # Immediately block on the asynchronous request.
+      send_async_request(request).call
+    end
+
+    # Sends a request over the connection.
+    #
+    # @param request [#encode, #response_class] the request that should be
+    #   encoded and written.
+    #
+    # @return [AsyncResponse] the async response, allowing the caller to choose
+    #   when to block.
+    def send_async_request(request)
       # Default notification payload.
       notification = {
         broker_host: @host,
@@ -83,15 +128,41 @@ module Kafka
         response_size: 0,
       }
 
-      @instrumenter.instrument("request.connection", notification) do
-        open unless open?
+      @instrumenter.start("request.connection", notification)
+
+      open unless open?
+
+      @correlation_id += 1
 
-        @correlation_id += 1
+      write_request(request, notification)
 
-        write_request(request, notification)
+      response_class = request.response_class
+      correlation_id = @correlation_id
 
-        response_class = request.response_class
-        wait_for_response(response_class, notification) unless response_class.nil?
+      if response_class.nil?
+        async_response = AsyncResponse.new(Protocol::NullResponse) { nil }
+
+        # Immediately deliver a nil value.
+        async_response.deliver(nil)
+
+        @instrumenter.finish("request.connection", notification)
+
+        async_response
+      else
+        async_response = AsyncResponse.new(response_class) {
+          # A caller is trying to read the response, so we have to wait for it
+          # before we can return.
+          wait_for_response(correlation_id, notification)
+
+          # Once done, we can finish the instrumentation.
+          @instrumenter.finish("request.connection", notification)
+        }
+
+        # Store the asynchronous response so that data can be delivered to it
+        # at a later time.
+        @pending_async_responses[correlation_id] = async_response
+
+        async_response
       end
     rescue Errno::EPIPE, Errno::ECONNRESET, Errno::ETIMEDOUT, EOFError => e
       close
@@ -115,6 +186,9 @@ module Kafka
 
       # Correlation id is initialized to zero and bumped for each request.
       @correlation_id = 0
+
+      # The pipeline of pending response futures must be reset.
+      @pending_async_responses = {}
     rescue Errno::ETIMEDOUT => e
       @logger.error "Timed out while trying to connect to #{self}: #{e}"
       raise ConnectionError, e
@@ -156,8 +230,8 @@ module Kafka
     #   a given Decoder.
     #
     # @return [nil]
-    def read_response(response_class, notification)
-      @logger.debug "Waiting for response #{@correlation_id} from #{to_s}"
+    def read_response(expected_correlation_id, notification)
+      @logger.debug "Waiting for response #{expected_correlation_id} from #{to_s}"
 
       data = @decoder.bytes
       notification[:response_size] = data.bytesize
@@ -166,32 +240,49 @@ module Kafka
       response_decoder = Kafka::Protocol::Decoder.new(buffer)
 
       correlation_id = response_decoder.int32
-      response = response_class.decode(response_decoder)
 
       @logger.debug "Received response #{correlation_id} from #{to_s}"
 
-      return correlation_id, response
+      return correlation_id, response_decoder
     rescue Errno::ETIMEDOUT
-      @logger.error "Timed out while waiting for response #{@correlation_id}"
+      @logger.error "Timed out while waiting for response #{expected_correlation_id}"
       raise
+    rescue Errno::EPIPE, Errno::ECONNRESET, Errno::ETIMEDOUT, EOFError => e
+      close
+
+      raise ConnectionError, "Connection error: #{e}"
     end
 
-    def wait_for_response(response_class, notification)
+    def wait_for_response(expected_correlation_id, notification)
       loop do
-        correlation_id, response = read_response(response_class, notification)
-
-        # There may have been a previous request that timed out before the client
-        # was able to read the response. In that case, the response will still be
-        # sitting in the socket waiting to be read. If the response we just read
-        # was to a previous request, we can safely skip it.
-        if correlation_id < @correlation_id
-          @logger.error "Received out-of-order response id #{correlation_id}, was expecting #{@correlation_id}"
-        elsif correlation_id > @correlation_id
-          raise Kafka::Error, "Correlation id mismatch: expected #{@correlation_id} but got #{correlation_id}"
+        correlation_id, data = read_response(expected_correlation_id, notification)
+
+        if correlation_id < expected_correlation_id
+          # There may have been a previous request that timed out before the client
+          # was able to read the response. In that case, the response will still be
+          # sitting in the socket waiting to be read. If the response we just read
+          # was to a previous request, we deliver it to the pending async response
+          # future.
+          async_response = @pending_async_responses.delete(correlation_id)
+          async_response.deliver(data) if async_response
+        elsif correlation_id > expected_correlation_id
+          raise Kafka::Error, "Correlation id mismatch: expected #{expected_correlation_id} but got #{correlation_id}"
         else
-          return response
+          # If the request was asynchronous, deliver the response to the pending
+          # async response future.
+          async_response = @pending_async_responses.delete(correlation_id)
+          async_response.deliver(data)
+
+          return async_response.call
         end
       end
+    rescue Errno::EPIPE, Errno::ECONNRESET, Errno::ETIMEDOUT, EOFError => e
+      notification[:exception] = [e.class.name, e.message]
+      notification[:exception_object] = e
+
+      close
+
+      raise ConnectionError, "Connection error: #{e}"
     end
   end
 end