rdkafka 0.1.11 → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 8d6da9327e4ab83441c784ccb89783e0928821e6
-  data.tar.gz: b6812cb4eee125203fd73efa1904b63bb0670d31
+  metadata.gz: 33e13eee28a6f2356635744a0490e06d236afd9d
+  data.tar.gz: 23a74b8693241447df18042c3cf0482a03ec9c82
 SHA512:
-  metadata.gz: b155e6b7d3358ba451ba88ce6bde6cf327ff7db26275b76b1c24d6010b0f015eef7df26acf5362230872163ea62444919164e3f1e79f04d8c3093932b53e6e60
-  data.tar.gz: 01d58aed27bc1f385c2d3bcb22e964ceff47c0582c3bccc3e6af6f88d2c4806ea3c3d0035d0b52d45522a3924722a506d97e1986b4f7babe558619cbfc9ed3ba
+  metadata.gz: 2c130f0bfa4a968186cf51490e7453e81ac879c2ff3fa082707332235a6d98fc94e25c6278bac249f05a62afbea2cc70534bd05fd24ee07e1754418cf909d156
+  data.tar.gz: 5c5d186816373f5cd28a5d7cc583a79cfded06522d4707da855373e06ce57ff90903c639a1232e535abfa692f27a395e699d4f6b47792a97b9777ada224c8e44

data/.gitignore

@@ -4,3 +4,4 @@ ext/tmp
 ext/librdkafka.*
 *.gem
 .yardoc
+doc

data/.travis.yml

@@ -0,0 +1,22 @@
+language: ruby
+
+sudo: false
+
+rvm:
+  - 2.1
+  - 2.2
+  - 2.3
+  - 2.4
+
+before_install:
+  - wget http://www.us.apache.org/dist/kafka/0.11.0.1/kafka_2.12-0.11.0.1.tgz -O kafka.tgz
+  - mkdir -p kafka && tar xzf kafka.tgz -C kafka --strip-components 1
+  - nohup bash -c "cd kafka && bin/zookeeper-server-start.sh config/zookeeper.properties &"
+  - nohup bash -c "cd kafka && bin/kafka-server-start.sh config/server.properties &"
+
+before_script:
+  - cd ext && bundle exec rake && cd ..
+  - bundle exec rake create_topics
+
+script:
+  - bundle exec rspec

data/.yardopts

@@ -0,0 +1,2 @@
+--no-private
+--markup=markdown

data/CHANGELOG.md

@@ -0,0 +1,5 @@
+# 0.2.0
+* Some refactoring and add inline documentation
+
+# 0.1.x
+* Initial working version including producing and consuming

data/README.md

@@ -1,5 +1,6 @@
 # Rdkafka
 
+[![Build Status](https://travis-ci.org/thijsc/rdkafka-ruby.svg?branch=master)](https://travis-ci.org/thijsc/rdkafka-ruby)
 [![Gem Version](https://badge.fury.io/rb/rdkafka.svg)](https://badge.fury.io/rb/rdkafka)
 
 The `rdkafka` gem is a modern Kafka client library for Ruby based on
@@ -11,7 +12,45 @@ This gem only provides a high-level Kafka consumer. If you are running
 an older version of Kafka and/or need the legacy simple consumer we
 suggest using the [Hermann](https://github.com/reiseburo/hermann) gem.
 
-Documentation is available on [RubyDoc](http://www.rubydoc.info/github/thijsc/rdkafka-ruby/master).
+## Installation
+
+This gem downloads and compiles librdkafka when it is installed. If you
+have any problems installing the gem please open an issue.
+
+## Usage
+
+See the [documentation](http://www.rubydoc.info/github/thijsc/rdkafka-ruby/master) for full details on how to use this gem. Two quick examples:
+
+### Consuming messages
+
+```ruby
+config = {
+  :"bootstrap.servers" => "localhost:9092",
+  :"group.id" => "ruby-test"
+}
+consumer = Rdkafka::Config.new(config).consumer
+consumer.subscribe("ruby-test-topic")
+
+consumer.each do |message|
+  puts "Message received: #{message}"
+end
+```
+
+### Producing messages
+
+```ruby
+config = {:"bootstrap.servers" => "localhost:9092"}
+producer = Rdkafka::Config.new(config).producer
+
+100.times do |i|
+  puts "Producing message #{i}"
+  producer.produce(
+      topic:   "ruby-test-topic",
+      payload: "Payload #{i}",
+      key:     "Key #{i}"
+  ).wait
+end
+```
 
 ## Development
 

data/Rakefile

@@ -2,8 +2,13 @@ require "./lib/rdkafka"
 
 task :create_topics do
   puts "Creating test topics"
-  `kafka-topics --create --topic=produce_test_topic --zookeeper=127.0.0.1:2181 --partitions=3 --replication-factor=1`
-  `kafka-topics --create --topic=rake_test_topic --zookeeper=127.0.0.1:2181 --partitions=3 --replication-factor=1`
+  kafka_topics = if ENV['TRAVIS']
+                   'kafka/bin/kafka-topics.sh'
+                 else
+                   'kafka-topics'
+                 end
+  `#{kafka_topics} --create --topic=produce_test_topic --zookeeper=127.0.0.1:2181 --partitions=3 --replication-factor=1`
+  `#{kafka_topics} --create --topic=rake_test_topic --zookeeper=127.0.0.1:2181 --partitions=3 --replication-factor=1`
 end
 
 task :produce_messages do

data/lib/rdkafka.rb

@@ -2,7 +2,9 @@ require "rdkafka/version"
 
 require "rdkafka/config"
 require "rdkafka/consumer"
+require "rdkafka/consumer/message"
 require "rdkafka/error"
 require "rdkafka/ffi"
-require "rdkafka/message"
 require "rdkafka/producer"
+require "rdkafka/producer/delivery_handle"
+require "rdkafka/producer/delivery_report"

data/lib/rdkafka/config.rb

@@ -5,38 +5,72 @@ module Rdkafka
   # the consumer and producer methods to create a client. Documentation of the available
   # configuration options is available on https://github.com/edenhill/librdkafka/blob/master/CONFIGURATION.md.
   class Config
+    # @private
     @@logger = Logger.new(STDOUT)
 
+    # Returns the current logger, by default this is a logger to stdout.
+    #
+    # @return [Logger]
     def self.logger
       @@logger
     end
 
+    # Set the logger that will be used for all logging output by this library.
+    #
+    # @param logger [Logger] The logger to be used
+    #
+    # @return [nil]
     def self.logger=(logger)
+      raise NoLoggerError if logger.nil?
       @@logger=logger
     end
 
+    # Default config that can be overwritten.
     DEFAULT_CONFIG = {
       # Request api version so advanced features work
       :"api.version.request" => true
     }.freeze
 
+    # Required config that cannot be overwritten.
     REQUIRED_CONFIG = {
-      # Enable log queues so we get callbacks in our own threads
+      # Enable log queues so we get callbacks in our own Ruby threads
       :"log.queue" => true
     }.freeze
 
+    # Returns a new config with the provided options which are merged with {DEFAULT_CONFIG}.
+    #
+    # @param config_hash [Hash<String,Symbol => String>] The config options for rdkafka
+    #
+    # @return [Config]
     def initialize(config_hash = {})
       @config_hash = DEFAULT_CONFIG.merge(config_hash)
     end
 
+    # Set a config option.
+    #
+    # @param key [String] The config option's key
+    # @param value [String] The config option's value
+    #
+    # @return [nil]
     def []=(key, value)
       @config_hash[key] = value
     end
 
+    # Get a config option with the specified key
+    #
+    # @param key [String] The config option's key
+    #
+    # @return [String, nil] The config option or `nil` if it is not present
     def [](key)
       @config_hash[key]
     end
 
+    # Create a consumer with this configuration.
+    #
+    # @raise [ConfigError] When the configuration contains invalid options
+    # @raise [ClientCreationError] When the native client cannot be created
+    #
+    # @return [Consumer] The created consumer
     def consumer
       kafka = native_kafka(native_config, :rd_kafka_consumer)
       # Redirect the main queue to the consumer
@@ -45,6 +79,12 @@ module Rdkafka
       Rdkafka::Consumer.new(kafka)
     end
 
+    # Create a producer with this configuration.
+    #
+    # @raise [ConfigError] When the configuration contains invalid options
+    # @raise [ClientCreationError] When the native client cannot be created
+    #
+    # @return [Producer] The created producer
     def producer
       # Create Kafka config
       config = native_config
@@ -54,9 +94,15 @@ module Rdkafka
       Rdkafka::Producer.new(native_kafka(config, :rd_kafka_producer))
     end
 
+    # Error that is returned by the underlying rdkafka error if an invalid configuration option is present.
     class ConfigError < RuntimeError; end
+
+    # Error that is returned by the underlying rdkafka library if the client cannot be created.
     class ClientCreationError < RuntimeError; end
 
+    # Error that is raised when trying to set a nil logger
+    class NoLoggerError < RuntimeError; end
+
     private
 
     # This method is only intented to be used to create a client,

data/lib/rdkafka/consumer.rb

@@ -1,15 +1,31 @@
 module Rdkafka
+  # A consumer of Kafka messages. It uses the high-level consumer approach where the Kafka
+  # brokers automatically assign partitions and load balance partitions over consumers that
+  # have the same `:"group.id"` set in their configuration.
+  #
+  # To create a consumer set up a {Config} and call {Config#consumer consumer} on that. It is
+  # mandatory to set `:"group.id"` in the configuration.
   class Consumer
     include Enumerable
 
+    # @private
     def initialize(native_kafka)
       @native_kafka = native_kafka
     end
 
+    # Close this consumer
+    # @return [nil]
     def close
       Rdkafka::FFI.rd_kafka_consumer_close(@native_kafka)
     end
 
+    # Subscribe to one or more topics
+    #
+    # @param topics [Array<String>] One or more topic names
+    #
+    # @raise [RdkafkaError] When subscribing fails
+    #
+    # @return [nil]
     def subscribe(*topics)
       # Create topic partition list with topics and no partition set
       tpl = Rdkafka::FFI.rd_kafka_topic_partition_list_new(topics.length)
@@ -30,6 +46,13 @@ module Rdkafka
       Rdkafka::FFI.rd_kafka_topic_partition_list_destroy(tpl)
     end
 
+    # Commit the current offsets of this consumer
+    #
+    # @param async [Boolean] Whether to commit async or wait for the commit to finish
+    #
+    # @raise [RdkafkaError] When comitting fails
+    #
+    # @return [nil]
     def commit(async=false)
       response = Rdkafka::FFI.rd_kafka_commit(@native_kafka, nil, async)
       if response != 0
@@ -37,6 +60,13 @@ module Rdkafka
       end
     end
 
+    # Poll for the next message on one of the subscribed topics
+    #
+    # @param timeout_ms [Integer] Timeout of this poll
+    #
+    # @raise [RdkafkaError] When polling fails
+    #
+    # @return [Message, nil] A message or nil if there was no new message within the timeout
     def poll(timeout_ms)
       message_ptr = Rdkafka::FFI.rd_kafka_consumer_poll(@native_kafka, timeout_ms)
       if message_ptr.null?
@@ -49,7 +79,7 @@ module Rdkafka
           raise Rdkafka::RdkafkaError.new(native_message[:err])
         end
         # Create a message to pass out
-        Rdkafka::Message.new(native_message)
+        Rdkafka::Consumer::Message.new(native_message)
       end
     ensure
       # Clean up rdkafka message if there is one
@@ -58,6 +88,13 @@ module Rdkafka
       end
     end
 
+    # Poll for new messages and yield for each received one
+    #
+    # @raise [RdkafkaError] When polling fails
+    #
+    # @yieldparam message [Message] Received message
+    #
+    # @return [nil]
     def each(&block)
       loop do
         message = poll(250)

data/lib/rdkafka/consumer/message.rb

@@ -0,0 +1,51 @@
+module Rdkafka
+  class Consumer
+    # A message that was consumed from a topic.
+    class Message
+      # The topic this message was consumed from
+      # @return [String]
+      attr_reader :topic
+
+      # The partition this message was consumed from
+      # @return [Integer]
+      attr_reader :partition
+
+      # This message's payload
+      # @return [String, nil]
+      attr_reader :payload
+
+      # This message's key
+      # @return [String, nil]
+      attr_reader :key
+
+      # This message's offset in it's partition
+      # @return [Integer]
+      attr_reader :offset
+
+      # This message's timestamp, if provided by the broker
+      # @return [Integer, nil]
+      attr_reader :timestamp
+
+      # @private
+      def initialize(native_message)
+        unless native_message[:rkt].null?
+          @topic = FFI.rd_kafka_topic_name(native_message[:rkt])
+        end
+        @partition = native_message[:partition]
+        unless native_message[:payload].null?
+          @payload = native_message[:payload].read_string(native_message[:len])
+        end
+        unless native_message[:key].null?
+          @key = native_message[:key].read_string(native_message[:key_len])
+        end
+        @offset = native_message[:offset]
+        @timestamp = FFI.rd_kafka_message_timestamp(native_message, nil)
+      end
+
+      # @return [String]
+      def to_s
+        "Message in '#{topic}' with key '#{key}', payload '#{payload}', partition #{partition}, offset #{offset}, timestamp #{timestamp}"
+      end
+    end
+  end
+end

data/lib/rdkafka/error.rb

@@ -1,12 +1,18 @@
 module Rdkafka
+  # Error returned by the underlying rdkafka library.
   class RdkafkaError < RuntimeError
+    # The underlying raw error response
+    # @return [Integer]
     attr_reader :rdkafka_response
 
+    # @private
     def initialize(response)
       raise TypeError.new("Response has to be an integer") unless response.is_a? Integer
       @rdkafka_response = response
     end
 
+    # This error's code, for example `:partition_eof`, `:msg_size_too_large`.
+    # @return [Symbol]
     def code
       code = Rdkafka::FFI.rd_kafka_err2name(@rdkafka_response).downcase
       if code[0] == "_"
@@ -16,10 +22,14 @@ module Rdkafka
       end
     end
 
+    # Human readable representation of this error.
+    # @return [String]
     def to_s
       "#{Rdkafka::FFI.rd_kafka_err2str(@rdkafka_response)} (#{code})"
     end
 
+    # Whether this error indicates the partition is EOF.
+    # @return [Boolean]
     def is_partition_eof?
       code == :partition_eof
     end

data/lib/rdkafka/ffi.rb

@@ -2,6 +2,7 @@ require "ffi"
 require "logger"
 
 module Rdkafka
+  # @private
   module FFI
     extend ::FFI::Library
 
@@ -144,7 +145,7 @@ module Rdkafka
       :void, [:pointer, :pointer, :pointer]
     ) do |client_ptr, message_ptr, opaque_ptr|
       message = Message.new(message_ptr)
-      delivery_handle = Rdkafka::DeliveryHandle.new(message[:_private])
+      delivery_handle = Rdkafka::Producer::DeliveryHandle.new(message[:_private])
       delivery_handle[:pending] = false
       delivery_handle[:response] = message[:err]
       delivery_handle[:partition] = message[:partition]

data/lib/rdkafka/producer.rb

@@ -1,5 +1,7 @@
 module Rdkafka
+  # A producer for Kafka messages. To create a producer set up a {Config} and call {Config#producer producer} on that.
   class Producer
+    # @private
     def initialize(native_kafka)
       @closing = false
       @native_kafka = native_kafka
@@ -16,6 +18,7 @@ module Rdkafka
       @polling_thread.abort_on_exception = true
     end
 
+    # Close this producer and wait for the internal poll queue to empty.
     def close
       # Indicate to polling thread that we're closing
       @closing = true
@@ -23,6 +26,20 @@ module Rdkafka
       @polling_thread.join
     end
 
+    # Produces a message to a Kafka topic. The message is added to rdkafka's queue, call {DeliveryHandle#wait wait} on the returned delivery handle to make sure it is delivered.
+    #
+    # When no partition is specified the underlying Kafka library picks a partition based on the key. If no key is specified, a random partition will be used.
+    # When a timestamp is provided this is used instead of the autogenerated timestamp.
+    #
+    # @param topic [String] The topic to produce to
+    # @param payload [String] The message's payload
+    # @param key [String] The message's key
+    # @param partition [Integer] Optional partition to produce to
+    # @param timestamp [Integer] Optional timestamp of this message
+    #
+    # @raise [RdkafkaError] When adding the message to rdkafka's queue failed
+    #
+    # @return [DeliveryHandle] Delivery handle that can be used to wait for the result of producing this message
     def produce(topic:, payload: nil, key: nil, partition: nil, timestamp: nil)
       # Start by checking and converting the input
 
@@ -74,48 +91,4 @@ module Rdkafka
       delivery_handle
     end
   end
-
-  class WaitTimeoutError < RuntimeError; end
-
-  class DeliveryHandle < ::FFI::Struct
-    layout :pending, :bool,
-           :response, :int,
-           :partition, :int,
-           :offset, :int64
-
-    def pending?
-      self[:pending]
-    end
-
-    # Wait for the delivery report
-    def wait(timeout_in_seconds=60)
-      timeout = if timeout_in_seconds
-                  Time.now.to_i + timeout_in_seconds
-                else
-                  nil
-                end
-      loop do
-        if pending?
-          if timeout && timeout <= Time.now.to_i
-            raise WaitTimeoutError.new("Waiting for delivery timed out after #{timeout_in_seconds} seconds")
-          end
-          sleep 0.1
-          next
-        elsif self[:response] != 0
-          raise RdkafkaError.new(self[:response])
-        else
-          return DeliveryReport.new(self[:partition], self[:offset])
-        end
-      end
-    end
-  end
-
-  class DeliveryReport
-    attr_reader :partition, :offset
-
-    def initialize(partition, offset)
-      @partition = partition
-      @offset = offset
-    end
-  end
 end

data/lib/rdkafka/producer/delivery_handle.rb

@@ -0,0 +1,54 @@
+module Rdkafka
+  class Producer
+    # Handle to wait for a delivery report which is returned when
+    # producing a message.
+    class DeliveryHandle < ::FFI::Struct
+      layout :pending, :bool,
+             :response, :int,
+             :partition, :int,
+             :offset, :int64
+
+      # Whether the delivery handle is still pending.
+      #
+      # @return [Boolean]
+      def pending?
+        self[:pending]
+      end
+
+      # Wait for the delivery report or raise an error if this takes longer than the timeout.
+      # If there is a timeout this does not mean the message is not delivered, rdkafka might still be working on delivering the message.
+      # In this case it is possible to call wait again.
+      #
+      # @param timeout_in_seconds [Integer, nil] Number of seconds to wait before timing out. If this is nil it does not time out.
+      #
+      # @raise [RdkafkaError] When delivering the message failed
+      # @raise [WaitTimeoutError] When the timeout has been reached and the handle is still pending
+      #
+      # @return [DeliveryReport]
+      def wait(timeout_in_seconds=60)
+        timeout = if timeout_in_seconds
+                    Time.now.to_i + timeout_in_seconds
+                  else
+                    nil
+                  end
+        loop do
+          if pending?
+            if timeout && timeout <= Time.now.to_i
+              raise WaitTimeoutError.new("Waiting for delivery timed out after #{timeout_in_seconds} seconds")
+            end
+            sleep 0.1
+            next
+          elsif self[:response] != 0
+            raise RdkafkaError.new(self[:response])
+          else
+            return DeliveryReport.new(self[:partition], self[:offset])
+          end
+        end
+      end
+
+      # Error that is raised when waiting for a delivery handle to complete
+      # takes longer than the specified timeout.
+      class WaitTimeoutError < RuntimeError; end
+    end
+  end
+end

data/lib/rdkafka/producer/delivery_report.rb

@@ -0,0 +1,21 @@
+module Rdkafka
+  class Producer
+    # Delivery report for a succesfully produced message.
+    class DeliveryReport
+      # The partition this message was produced to.
+      # @return [Integer]
+      attr_reader :partition
+
+      # The offset of the produced message.
+      # @return [Integer]
+      attr_reader :offset
+
+      private
+
+      def initialize(partition, offset)
+        @partition = partition
+        @offset = offset
+      end
+    end
+  end
+end

data/lib/rdkafka/version.rb

@@ -1,4 +1,4 @@
 module Rdkafka
-  VERSION = "0.1.11"
+  VERSION = "0.2.0"
   LIBRDKAFKA_VERSION = "0.11.0"
 end

data/spec/rdkafka/config_spec.rb

@@ -1,36 +1,57 @@
 require "spec_helper"
 
 describe Rdkafka::Config do
-  it "should store configuration" do
-    config = Rdkafka::Config.new
-    config[:"key"] = 'value'
-    expect(config[:"key"]).to eq 'value'
-  end
+  context "logger" do
+    it "should have a default logger" do
+      expect(Rdkafka::Config.logger).to be_a Logger
+    end
 
-  it "should use default configuration" do
-    config = Rdkafka::Config.new
-    expect(config[:"api.version.request"]).to eq true
-  end
+    it "should set the logger" do
+      logger = Logger.new(STDOUT)
+      expect(Rdkafka::Config.logger).not_to eq logger
+      Rdkafka::Config.logger = logger
+      expect(Rdkafka::Config.logger).to eq logger
+    end
 
-  it "should create a consumer with valid config" do
-    expect(rdkafka_config.consumer).to be_a Rdkafka::Consumer
+    it "should not accept a nil logger" do
+      expect {
+        Rdkafka::Config.logger = nil
+      }.to raise_error(Rdkafka::Config::NoLoggerError)
+    end
   end
 
-  it "should raise an error when creating a consumer with invalid config" do
-    config = Rdkafka::Config.new('invalid.key' => 'value')
-    expect {
-      config.consumer
-    }.to raise_error(Rdkafka::Config::ConfigError, "No such configuration property: \"invalid.key\"")
-  end
+  context "configuration" do
+    it "should store configuration" do
+      config = Rdkafka::Config.new
+      config[:"key"] = 'value'
+      expect(config[:"key"]).to eq 'value'
+    end
 
-  it "should create a producer with valid config" do
-    expect(rdkafka_config.producer).to be_a Rdkafka::Producer
-  end
+    it "should use default configuration" do
+      config = Rdkafka::Config.new
+      expect(config[:"api.version.request"]).to eq true
+    end
+
+    it "should create a consumer with valid config" do
+      expect(rdkafka_config.consumer).to be_a Rdkafka::Consumer
+    end
+
+    it "should raise an error when creating a consumer with invalid config" do
+      config = Rdkafka::Config.new('invalid.key' => 'value')
+      expect {
+        config.consumer
+      }.to raise_error(Rdkafka::Config::ConfigError, "No such configuration property: \"invalid.key\"")
+    end
+
+    it "should create a producer with valid config" do
+      expect(rdkafka_config.producer).to be_a Rdkafka::Producer
+    end
 
-  it "should raise an error when creating a producer with invalid config" do
-    config = Rdkafka::Config.new('invalid.key' => 'value')
-    expect {
-      config.producer
-    }.to raise_error(Rdkafka::Config::ConfigError, "No such configuration property: \"invalid.key\"")
+    it "should raise an error when creating a producer with invalid config" do
+      config = Rdkafka::Config.new('invalid.key' => 'value')
+      expect {
+        config.producer
+      }.to raise_error(Rdkafka::Config::ConfigError, "No such configuration property: \"invalid.key\"")
+    end
   end
 end

data/spec/rdkafka/{message_spec.rb → consumer/message_spec.rb}

@@ -1,6 +1,6 @@
 require "spec_helper"
 
-describe Rdkafka::Message do
+describe Rdkafka::Consumer::Message do
   let(:native_topic) do
     Rdkafka::FFI.rd_kafka_topic_new(
       native_client,
@@ -29,7 +29,7 @@ describe Rdkafka::Message do
       end
     end
   end
-  subject { Rdkafka::Message.new(native_message) }
+  subject { Rdkafka::Consumer::Message.new(native_message) }
 
   it "should have a topic" do
     expect(subject.topic).to eq "topic_name"
@@ -72,6 +72,10 @@ describe Rdkafka::Message do
   end
 
   it "should have a timestamp" do
-    expect(subject.timestamp).to be > 0
+    # There is no effective way to mock this this, just
+    # make sure it doesn't crash.
+    expect {
+      subject.timestamp
+    }.not_to raise_error
   end
 end

data/spec/rdkafka/producer/delivery_handle_spec.rb

@@ -0,0 +1,63 @@
+require "spec_helper"
+
+describe Rdkafka::Producer::DeliveryHandle do
+  let(:response) { 0 }
+  subject do
+    Rdkafka::Producer::DeliveryHandle.new.tap do |handle|
+      handle[:pending] = pending
+      handle[:response] = response
+      handle[:partition] = 2
+      handle[:offset] = 100
+    end
+  end
+
+  describe "#pending?" do
+    context "when true" do
+      let(:pending) { true }
+
+      it "should be true" do
+        expect(subject.pending?).to be true
+      end
+    end
+
+    context "when not true" do
+      let(:pending) { false }
+
+      it "should be false" do
+        expect(subject.pending?).to be false
+      end
+    end
+  end
+
+  describe "#wait" do
+    let(:pending) { true }
+
+    it "should wait until the timeout and then raise an error" do
+      expect {
+        subject.wait(0.1)
+      }.to raise_error Rdkafka::Producer::DeliveryHandle::WaitTimeoutError
+    end
+
+    context "when not pending anymore and no error" do
+      let(:pending) { false }
+
+      it "should return a delivery report" do
+        report = subject.wait
+
+        expect(report.partition).to eq(2)
+        expect(report.offset).to eq(100)
+      end
+    end
+
+    context "when not pending anymore and there was an error" do
+      let(:pending) { false }
+      let(:response) { 20 }
+
+      it "should raise an rdkafka error" do
+        expect {
+          subject.wait
+        }.to raise_error Rdkafka::RdkafkaError
+      end
+    end
+  end
+end

data/spec/rdkafka/producer/delivery_report_spec.rb

@@ -0,0 +1,13 @@
+require "spec_helper"
+
+describe Rdkafka::Producer::DeliveryReport do
+  subject { Rdkafka::Producer::DeliveryReport.new(2, 100) }
+
+  it "should get the partition" do
+    expect(subject.partition).to eq 2
+  end
+
+  it "should get the offset" do
+    expect(subject.offset).to eq 100
+  end
+end

data/spec/rdkafka/producer_spec.rb

@@ -63,6 +63,7 @@ describe Rdkafka::Producer do
       delivery_report: report
     )
 
+    expect(message.partition).to eq 1
     expect(message.payload.force_encoding("utf-8")).to eq "Τη γλώσσα μου έδωσαν ελληνική"
     expect(message.key).to eq "key utf8"
   end
@@ -70,7 +71,7 @@ describe Rdkafka::Producer do
   it "should produce a message with a timestamp" do
     handle = producer.produce(
       topic:     "produce_test_topic",
-      payload:   "Payload 1",
+      payload:   "Payload timestamp",
       key:       "key timestamp",
       timestamp: 1505069646000
     )
@@ -88,6 +89,7 @@ describe Rdkafka::Producer do
       delivery_report: report
     )
 
+    expect(message.partition).to eq 2
     expect(message.key).to eq "key timestamp"
     expect(message.timestamp).to eq 1505069646000
   end
@@ -100,6 +102,6 @@ describe Rdkafka::Producer do
     )
     expect {
       handle.wait(0)
-    }.to raise_error Rdkafka::WaitTimeoutError
+    }.to raise_error Rdkafka::Producer::DeliveryHandle::WaitTimeoutError
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: rdkafka
 version: !ruby/object:Gem::Version
-  version: 0.1.11
+  version: 0.2.0
 platform: ruby
 authors:
 - Thijs Cadier
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2017-09-10 00:00:00.000000000 Z
+date: 2017-10-13 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: ffi
@@ -89,6 +89,9 @@ extensions:
 extra_rdoc_files: []
 files:
 - ".gitignore"
+- ".travis.yml"
+- ".yardopts"
+- CHANGELOG.md
 - Gemfile
 - LICENSE
 - README.md
@@ -97,17 +100,21 @@ files:
 - lib/rdkafka.rb
 - lib/rdkafka/config.rb
 - lib/rdkafka/consumer.rb
+- lib/rdkafka/consumer/message.rb
 - lib/rdkafka/error.rb
 - lib/rdkafka/ffi.rb
-- lib/rdkafka/message.rb
 - lib/rdkafka/producer.rb
+- lib/rdkafka/producer/delivery_handle.rb
+- lib/rdkafka/producer/delivery_report.rb
 - lib/rdkafka/version.rb
 - rdkafka.gemspec
 - spec/rdkafka/config_spec.rb
+- spec/rdkafka/consumer/message_spec.rb
 - spec/rdkafka/consumer_spec.rb
 - spec/rdkafka/error_spec.rb
 - spec/rdkafka/ffi_spec.rb
-- spec/rdkafka/message_spec.rb
+- spec/rdkafka/producer/delivery_handle_spec.rb
+- spec/rdkafka/producer/delivery_report_spec.rb
 - spec/rdkafka/producer_spec.rb
 - spec/spec_helper.rb
 homepage: https://github.com/thijsc/rdkafka-ruby
@@ -137,9 +144,11 @@ summary: Kafka client library wrapping librdkafka using the ffi gem and futures
   concurrent-ruby for Kafka 0.10+
 test_files:
 - spec/rdkafka/config_spec.rb
+- spec/rdkafka/consumer/message_spec.rb
 - spec/rdkafka/consumer_spec.rb
 - spec/rdkafka/error_spec.rb
 - spec/rdkafka/ffi_spec.rb
-- spec/rdkafka/message_spec.rb
+- spec/rdkafka/producer/delivery_handle_spec.rb
+- spec/rdkafka/producer/delivery_report_spec.rb
 - spec/rdkafka/producer_spec.rb
 - spec/spec_helper.rb

data/lib/rdkafka/message.rb

@@ -1,24 +0,0 @@
-module Rdkafka
-  class Message
-    attr_reader :topic, :partition, :payload, :key, :offset, :timestamp
-
-    def initialize(native_message)
-      unless native_message[:rkt].null?
-        @topic = FFI.rd_kafka_topic_name(native_message[:rkt])
-      end
-      @partition = native_message[:partition]
-      unless native_message[:payload].null?
-        @payload = native_message[:payload].read_string(native_message[:len])
-      end
-      unless native_message[:key].null?
-        @key = native_message[:key].read_string(native_message[:key_len])
-      end
-      @offset = native_message[:offset]
-      @timestamp = FFI.rd_kafka_message_timestamp(native_message, nil)
-    end
-
-    def to_s
-      "Message in '#{topic}' with key '#{key}', payload '#{payload}', partition '#{partition}', offset '#{offset}'"
-    end
-  end
-end