rdkafka 0.21.0 → 0.21.1.alpha2

data/spec/rdkafka/producer/partitions_count_spec.rb

@@ -0,0 +1,359 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+RSpec.describe Rdkafka::Producer::PartitionsCountCache do
+  let(:default_ttl) { 1 } # Reduced from 30 to speed up tests
+  let(:custom_ttl) { 0.5 } # Half the default TTL
+  let(:cache) { described_class.new(default_ttl) }
+  let(:custom_ttl_cache) { described_class.new(custom_ttl) }
+  let(:topic) { "test_topic" }
+  let(:topic2) { "test_topic2" }
+  let(:partition_count) { 5 }
+  let(:higher_partition_count) { 10 }
+  let(:lower_partition_count) { 3 }
+  let(:even_higher_partition_count) { 15 }
+
+  describe "#initialize" do
+    it "creates a cache with default TTL when no TTL is specified" do
+      standard_cache = described_class.new
+      expect(standard_cache).to be_a(described_class)
+    end
+
+    it "creates a cache with custom TTL when specified" do
+      expect(custom_ttl_cache).to be_a(described_class)
+    end
+  end
+
+  describe "#get" do
+    context "when cache is empty" do
+      it "yields to get the value and caches it" do
+        block_called = false
+        result = cache.get(topic) do
+          block_called = true
+          partition_count
+        end
+
+        expect(block_called).to be true
+        expect(result).to eq(partition_count)
+
+        # Verify caching by checking if block is called again
+        second_block_called = false
+        second_result = cache.get(topic) do
+          second_block_called = true
+          partition_count + 1 # Different value to ensure we get cached value
+        end
+
+        expect(second_block_called).to be false
+        expect(second_result).to eq(partition_count)
+      end
+    end
+
+    context "when cache has a value" do
+      before do
+        # Seed the cache with a value
+        cache.get(topic) { partition_count }
+      end
+
+      it "returns cached value without yielding if not expired" do
+        block_called = false
+        result = cache.get(topic) do
+          block_called = true
+          partition_count + 1 # Different value to ensure we get cached one
+        end
+
+        expect(block_called).to be false
+        expect(result).to eq(partition_count)
+      end
+
+      it "yields to get new value when TTL has expired" do
+        # Wait for TTL to expire
+        sleep(default_ttl + 0.1)
+
+        block_called = false
+        new_count = partition_count + 1
+        result = cache.get(topic) do
+          block_called = true
+          new_count
+        end
+
+        expect(block_called).to be true
+        expect(result).to eq(new_count)
+
+        # Verify the new value is cached
+        second_block_called = false
+        second_result = cache.get(topic) do
+          second_block_called = true
+          new_count + 1 # Different value again
+        end
+
+        expect(second_block_called).to be false
+        expect(second_result).to eq(new_count)
+      end
+
+      it "respects a custom TTL" do
+        # Seed the custom TTL cache with a value
+        custom_ttl_cache.get(topic) { partition_count }
+
+        # Wait for custom TTL to expire but not default TTL
+        sleep(custom_ttl + 0.1)
+
+        # Custom TTL cache should refresh
+        custom_block_called = false
+        custom_result = custom_ttl_cache.get(topic) do
+          custom_block_called = true
+          higher_partition_count
+        end
+
+        expect(custom_block_called).to be true
+        expect(custom_result).to eq(higher_partition_count)
+
+        # Default TTL cache should not refresh yet
+        default_block_called = false
+        default_result = cache.get(topic) do
+          default_block_called = true
+          higher_partition_count
+        end
+
+        expect(default_block_called).to be false
+        expect(default_result).to eq(partition_count)
+      end
+    end
+
+    context "when new value is obtained" do
+      before do
+        # Seed the cache with initial value
+        cache.get(topic) { partition_count }
+      end
+
+      it "updates cache when new value is higher than cached value" do
+        # Wait for TTL to expire
+        sleep(default_ttl + 0.1)
+
+        # Get higher value
+        result = cache.get(topic) { higher_partition_count }
+        expect(result).to eq(higher_partition_count)
+
+        # Verify it was cached
+        second_result = cache.get(topic) { fail "Should not be called" }
+        expect(second_result).to eq(higher_partition_count)
+      end
+
+      it "preserves higher cached value when new value is lower" do
+        # First update to higher value
+        sleep(default_ttl + 0.1)
+        cache.get(topic) { higher_partition_count }
+
+        # Then try to update to lower value
+        sleep(default_ttl + 0.1)
+        result = cache.get(topic) { lower_partition_count }
+
+        expect(result).to eq(higher_partition_count)
+
+        # and subsequent gets should return the previously cached higher value
+        second_result = cache.get(topic) { fail "Should not be called" }
+        expect(second_result).to eq(higher_partition_count)
+      end
+
+      it "handles multiple topics independently" do
+        # Set up both topics with different values
+        cache.get(topic) { partition_count }
+        cache.get(topic2) { higher_partition_count }
+
+        # Wait for TTL to expire
+        sleep(default_ttl + 0.1)
+
+        # Update first topic
+        first_result = cache.get(topic) { even_higher_partition_count }
+        expect(first_result).to eq(even_higher_partition_count)
+
+        # Update second topic independently
+        second_updated = higher_partition_count + 3
+        second_result = cache.get(topic2) { second_updated }
+        expect(second_result).to eq(second_updated)
+
+        # Both topics should have their updated values
+        expect(cache.get(topic) { fail "Should not be called" }).to eq(even_higher_partition_count)
+        expect(cache.get(topic2) { fail "Should not be called" }).to eq(second_updated)
+      end
+    end
+  end
+
+  describe "#set" do
+    context "when cache is empty" do
+      it "adds a new entry to the cache" do
+        cache.set(topic, partition_count)
+
+        # Verify through get
+        result = cache.get(topic) { fail "Should not be called" }
+        expect(result).to eq(partition_count)
+      end
+    end
+
+    context "when cache already has a value" do
+      before do
+        cache.set(topic, partition_count)
+      end
+
+      it "updates cache when new value is higher" do
+        cache.set(topic, higher_partition_count)
+
+        result = cache.get(topic) { fail "Should not be called" }
+        expect(result).to eq(higher_partition_count)
+      end
+
+      it "keeps original value when new value is lower" do
+        cache.set(topic, lower_partition_count)
+
+        result = cache.get(topic) { fail "Should not be called" }
+        expect(result).to eq(partition_count)
+      end
+
+      it "updates the timestamp even when keeping original value" do
+        # Set initial value
+        cache.set(topic, partition_count)
+
+        # Wait until close to TTL expiring
+        sleep(default_ttl - 0.2)
+
+        # Set lower value (should update timestamp but not value)
+        cache.set(topic, lower_partition_count)
+
+        # Wait a bit more, but still under the full TTL if timestamp was refreshed
+        sleep(0.3)
+
+        # Should still be valid due to timestamp refresh
+        result = cache.get(topic) { fail "Should not be called" }
+        expect(result).to eq(partition_count)
+      end
+    end
+
+    context "with concurrent access" do
+      it "correctly handles simultaneous updates to the same topic" do
+        # This test focuses on the final value after concurrent updates
+        threads = []
+
+        # Create 5 threads that all try to update the same topic with increasing values
+        5.times do |i|
+          threads << Thread.new do
+            value = 10 + i  # Start at 10 to ensure all are higher than initial value
+            cache.set(topic, value)
+          end
+        end
+
+        # Wait for all threads to complete
+        threads.each(&:join)
+
+        # The highest value (14) should be stored and accessible through get
+        result = cache.get(topic) { fail "Should not be called" }
+        expect(result).to eq(14)
+      end
+    end
+  end
+
+  describe "TTL behavior" do
+    it "treats entries as expired when they exceed TTL" do
+      # Set initial value
+      cache.get(topic) { partition_count }
+
+      # Wait just under TTL
+      sleep(default_ttl - 0.1)
+
+      # Value should still be cached (block should not be called)
+      result = cache.get(topic) { fail "Should not be called when cache is valid" }
+      expect(result).to eq(partition_count)
+
+      # Now wait to exceed TTL
+      sleep(0.2) # Total sleep is now default_ttl + 0.1
+
+      # Cache should be expired, block should be called
+      block_called = false
+      new_value = partition_count + 3
+      result = cache.get(topic) do
+        block_called = true
+        new_value
+      end
+
+      expect(block_called).to be true
+      expect(result).to eq(new_value)
+    end
+  end
+
+  describe "comprehensive scenarios" do
+    it "handles a full lifecycle of cache operations" do
+      # 1. Initial cache miss, fetch and store
+      result1 = cache.get(topic) { partition_count }
+      expect(result1).to eq(partition_count)
+
+      # 2. Cache hit
+      result2 = cache.get(topic) { fail "Should not be called" }
+      expect(result2).to eq(partition_count)
+
+      # 3. Attempt to set lower value
+      cache.set(topic, lower_partition_count)
+      result3 = cache.get(topic) { fail "Should not be called" }
+      # Should still return the higher original value
+      expect(result3).to eq(partition_count)
+
+      # 4. Set higher value
+      cache.set(topic, higher_partition_count)
+      result4 = cache.get(topic) { fail "Should not be called" }
+      expect(result4).to eq(higher_partition_count)
+
+      # 5. TTL expires, new value provided is lower
+      sleep(default_ttl + 0.1)
+      result5 = cache.get(topic) { lower_partition_count }
+      # This returns the highest value
+      expect(result5).to eq(higher_partition_count)
+
+      # 6. But subsequent get should return the higher cached value
+      result6 = cache.get(topic) { fail "Should not be called" }
+      expect(result6).to eq(higher_partition_count)
+
+      # 7. Set new highest value directly
+      even_higher = higher_partition_count + 5
+      cache.set(topic, even_higher)
+      result7 = cache.get(topic) { fail "Should not be called" }
+      expect(result7).to eq(even_higher)
+    end
+
+    it "handles multiple topics with different TTLs correctly" do
+      # Set up initial values
+      cache.get(topic) { partition_count }
+      custom_ttl_cache.get(topic) { partition_count }
+
+      # Wait past custom TTL but not default TTL
+      sleep(custom_ttl + 0.1)
+
+      # Default cache should NOT refresh (still within default TTL)
+      default_result = cache.get(topic) { fail "Should not be called for default cache" }
+      # Original value should be maintained
+      expect(default_result).to eq(partition_count)
+
+      # Custom TTL cache SHOULD refresh (past custom TTL)
+      custom_cache_value = partition_count + 8
+      custom_block_called = false
+      custom_result = custom_ttl_cache.get(topic) do
+        custom_block_called = true
+        custom_cache_value
+      end
+
+      expect(custom_block_called).to be true
+      expect(custom_result).to eq(custom_cache_value)
+
+      # Now wait past default TTL
+      sleep(default_ttl - custom_ttl + 0.1)
+
+      # Now default cache should also refresh
+      default_block_called = false
+      new_default_value = partition_count + 10
+      new_default_result = cache.get(topic) do
+        default_block_called = true
+        new_default_value
+      end
+
+      expect(default_block_called).to be true
+      expect(new_default_result).to eq(new_default_value)
+    end
+  end
+end

data/spec/rdkafka/producer_spec.rb

@@ -654,12 +654,11 @@ describe Rdkafka::Producer do
 
     context 'when the partition count value was cached but time expired' do
       before do
-        allow(::Process).to receive(:clock_gettime).and_return(0, 30.02)
-        producer.partition_count('consume_test_topic')
+        ::Rdkafka::Producer.partitions_count_cache = Rdkafka::Producer::PartitionsCountCache.new
         allow(::Rdkafka::Metadata).to receive(:new).and_call_original
       end
 
-      it 'expect not to query it again' do
+      it 'expect to query it again' do
         producer.partition_count('consume_test_topic')
         expect(::Rdkafka::Metadata).to have_received(:new)
       end
@@ -819,4 +818,174 @@ describe Rdkafka::Producer do
       end
     end
   end
+
+  describe "#produce with headers" do
+    it "should produce a message with array headers" do
+      headers = {
+        "version" => ["2.1.3", "2.1.4"],
+        "type" => "String"
+      }
+
+      report = producer.produce(
+        topic:     "consume_test_topic",
+        key:       "key headers",
+        headers:   headers
+      ).wait
+
+      message = wait_for_message(topic: "consume_test_topic", consumer: consumer, delivery_report: report)
+      expect(message).to be
+      expect(message.key).to eq('key headers')
+      expect(message.headers['type']).to eq('String')
+      expect(message.headers['version']).to eq(["2.1.3", "2.1.4"])
+    end
+
+    it "should produce a message with single value headers" do
+      headers = {
+        "version" => "2.1.3",
+        "type" => "String"
+      }
+
+      report = producer.produce(
+        topic:     "consume_test_topic",
+        key:       "key headers",
+        headers:   headers
+      ).wait
+
+      message = wait_for_message(topic: "consume_test_topic", consumer: consumer, delivery_report: report)
+      expect(message).to be
+      expect(message.key).to eq('key headers')
+      expect(message.headers['type']).to eq('String')
+      expect(message.headers['version']).to eq('2.1.3')
+    end
+  end
+
+
+  describe 'with active statistics callback' do
+    let(:producer) do
+      rdkafka_producer_config('statistics.interval.ms': 1_000).producer
+    end
+
+    let(:count_cache_hash) { described_class.partitions_count_cache.to_h }
+    let(:pre_statistics_ttl) { count_cache_hash.fetch('produce_test_topic', [])[0] }
+    let(:post_statistics_ttl) { count_cache_hash.fetch('produce_test_topic', [])[0] }
+
+    context "when using partition key" do
+      before do
+        Rdkafka::Config.statistics_callback = ->(*) {}
+
+        # This call will make a blocking request to the metadata cache
+        producer.produce(
+          topic:         "produce_test_topic",
+          payload:       "payload headers",
+          partition_key: "test"
+        ).wait
+
+        pre_statistics_ttl
+
+        # We wait to make sure that statistics are triggered and that there is a refresh
+        sleep(1.5)
+
+        post_statistics_ttl
+      end
+
+      it 'expect to update ttl on the partitions count cache via statistics' do
+        expect(pre_statistics_ttl).to be < post_statistics_ttl
+      end
+    end
+
+    context "when not using partition key" do
+      before do
+        Rdkafka::Config.statistics_callback = ->(*) {}
+
+        # This call will make a blocking request to the metadata cache
+        producer.produce(
+          topic:         "produce_test_topic",
+          payload:       "payload headers"
+        ).wait
+
+        pre_statistics_ttl
+
+        # We wait to make sure that statistics are triggered and that there is a refresh
+        sleep(1.5)
+
+        # This will anyhow be populated from statistic
+        post_statistics_ttl
+      end
+
+      it 'expect not to update ttl on the partitions count cache via blocking but via use stats' do
+        expect(pre_statistics_ttl).to be_nil
+        expect(post_statistics_ttl).not_to be_nil
+      end
+    end
+  end
+
+  describe 'without active statistics callback' do
+    let(:producer) do
+      rdkafka_producer_config('statistics.interval.ms': 1_000).producer
+    end
+
+    let(:count_cache_hash) { described_class.partitions_count_cache.to_h }
+    let(:pre_statistics_ttl) { count_cache_hash.fetch('produce_test_topic', [])[0] }
+    let(:post_statistics_ttl) { count_cache_hash.fetch('produce_test_topic', [])[0] }
+
+    context "when using partition key" do
+      before do
+        # This call will make a blocking request to the metadata cache
+        producer.produce(
+          topic:         "produce_test_topic",
+          payload:       "payload headers",
+          partition_key: "test"
+        ).wait
+
+        pre_statistics_ttl
+
+        # We wait to make sure that statistics are triggered and that there is a refresh
+        sleep(1.5)
+
+        post_statistics_ttl
+      end
+
+      it 'expect not to update ttl on the partitions count cache via statistics' do
+        expect(pre_statistics_ttl).to eq post_statistics_ttl
+      end
+    end
+
+    context "when not using partition key" do
+      before do
+        # This call will make a blocking request to the metadata cache
+        producer.produce(
+          topic:         "produce_test_topic",
+          payload:       "payload headers"
+        ).wait
+
+        pre_statistics_ttl
+
+        # We wait to make sure that statistics are triggered and that there is a refresh
+        sleep(1.5)
+
+        # This should not be populated because stats are not in use
+        post_statistics_ttl
+      end
+
+      it 'expect not to update ttl on the partitions count cache via anything' do
+        expect(pre_statistics_ttl).to be_nil
+        expect(post_statistics_ttl).to be_nil
+      end
+    end
+  end
+
+  describe 'with other fiber closing' do
+    context 'when we create many fibers and close producer in some of them' do
+      it 'expect not to crash ruby' do
+        10.times do |i|
+          producer = rdkafka_producer_config.producer
+
+          Fiber.new do
+            GC.start
+            producer.close
+          end.resume
+        end
+      end
+    end
+  end
 end

data/spec/spec_helper.rb

@@ -18,6 +18,9 @@ def rdkafka_base_config
     :"api.version.request" => false,
     :"broker.version.fallback" => "1.0",
     :"bootstrap.servers" => "localhost:9092",
+    # Display statistics and refresh often just to cover those in specs
+    :'statistics.interval.ms' => 1_000,
+    :'topic.metadata.refresh.interval.ms' => 1_000
   }
 end
 
@@ -125,6 +128,12 @@ RSpec.configure do |config|
   config.filter_run focus: true
   config.run_all_when_everything_filtered = true
 
+  config.before(:each) do
+    Rdkafka::Config.statistics_callback = nil
+    # We need to clear it so state does not leak between specs
+    Rdkafka::Producer.partitions_count_cache.to_h.clear
+  end
+
   config.before(:suite) do
     admin = rdkafka_config.admin
     {

metadata

@@ -1,41 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: rdkafka
 version: !ruby/object:Gem::Version
-  version: 0.21.0
+  version: 0.21.1.alpha2
 platform: ruby
 authors:
 - Thijs Cadier
 - Maciej Mensfeld
 bindir: bin
-cert_chain:
-- |
-  -----BEGIN CERTIFICATE-----
-  MIIEcDCCAtigAwIBAgIBATANBgkqhkiG9w0BAQsFADA/MRAwDgYDVQQDDAdjb250
-  YWN0MRcwFQYKCZImiZPyLGQBGRYHa2FyYWZrYTESMBAGCgmSJomT8ixkARkWAmlv
-  MB4XDTI0MDgyMzEwMTkyMFoXDTQ5MDgxNzEwMTkyMFowPzEQMA4GA1UEAwwHY29u
-  dGFjdDEXMBUGCgmSJomT8ixkARkWB2thcmFma2ExEjAQBgoJkiaJk/IsZAEZFgJp
-  bzCCAaIwDQYJKoZIhvcNAQEBBQADggGPADCCAYoCggGBAKjLhLjQqUlNayxkXnO+
-  PsmCDs/KFIzhrsYMfLZRZNaWmzV3ujljMOdDjd4snM2X06C41iVdQPWjpe3j8vVe
-  ZXEWR/twSbOP6Eeg8WVH2wCOo0x5i7yhVn4UBLH4JpfEMCbemVcWQ9ry9OMg4WpH
-  Uu4dRwxFV7hzCz3p0QfNLRI4miAxnGWcnlD98IJRjBAksTuR1Llj0vbOrDGsL9ZT
-  JeXP2gdRLd8SqzAFJEWrbeTBCBU7gfSh3oMg5SVDLjaqf7Kz5wC/8bDZydzanOxB
-  T6CDXPsCnllmvTNx2ei2T5rGYJOzJeNTmJLLK6hJWUlAvaQSvCwZRvFJ0tVGLEoS
-  flqSr6uGyyl1eMUsNmsH4BqPEYcAV6P2PKTv2vUR8AP0raDvZ3xL1TKvfRb8xRpo
-  vPopCGlY5XBWEc6QERHfVLTIVsjnls2/Ujj4h8/TSfqqYnaHKefIMLbuD/tquMjD
-  iWQsW2qStBV0T+U7FijKxVfrfqZP7GxQmDAc9o1iiyAa3QIDAQABo3cwdTAJBgNV
-  HRMEAjAAMAsGA1UdDwQEAwIEsDAdBgNVHQ4EFgQU3O4dTXmvE7YpAkszGzR9DdL9
-  sbEwHQYDVR0RBBYwFIESY29udGFjdEBrYXJhZmthLmlvMB0GA1UdEgQWMBSBEmNv
-  bnRhY3RAa2FyYWZrYS5pbzANBgkqhkiG9w0BAQsFAAOCAYEAVKTfoLXn7mqdSxIR
-  eqxcR6Huudg1jes81s1+X0uiRTR3hxxKZ3Y82cPsee9zYWyBrN8TA4KA0WILTru7
-  Ygxvzha0SRPsSiaKLmgOJ+61ebI4+bOORzIJLpD6GxCxu1r7MI4+0r1u1xe0EWi8
-  agkVo1k4Vi8cKMLm6Gl9b3wG9zQBw6fcgKwmpjKiNnOLP+OytzUANrIUJjoq6oal
-  TC+f/Uc0TLaRqUaW/bejxzDWWHoM3SU6aoLPuerglzp9zZVzihXwx3jPLUVKDFpF
-  Rl2lcBDxlpYGueGo0/oNzGJAAy6js8jhtHC9+19PD53vk7wHtFTZ/0ugDQYnwQ+x
-  oml2fAAuVWpTBCgOVFe6XCQpMKopzoxQ1PjKztW2KYxgJdIBX87SnL3aWuBQmhRd
-  i9zWxov0mr44TWegTVeypcWGd/0nxu1+QHVNHJrpqlPBRvwQsUm7fwmRInGpcaB8
-  ap8wNYvryYzrzvzUxIVFBVM5PacgkFqRmolCa8I7tdKQN+R1
-  -----END CERTIFICATE-----
-date: 2025-02-13 00:00:00.000000000 Z
+cert_chain: []
+date: 1980-01-02 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: ffi
@@ -171,8 +144,11 @@ extensions:
 - ext/Rakefile
 extra_rdoc_files: []
 files:
+- ".github/CODEOWNERS"
 - ".github/FUNDING.yml"
 - ".github/workflows/ci.yml"
+- ".github/workflows/push.yml"
+- ".github/workflows/verify-action-pins.yml"
 - ".gitignore"
 - ".rspec"
 - ".ruby-gemset"
@@ -184,7 +160,6 @@ files:
 - MIT-LICENSE
 - README.md
 - Rakefile
-- certs/cert.pem
 - dist/librdkafka-2.8.0.tar.gz
 - dist/patches/rdkafka_global_init.patch
 - docker-compose.yml
@@ -230,6 +205,7 @@ files:
 - lib/rdkafka/producer.rb
 - lib/rdkafka/producer/delivery_handle.rb
 - lib/rdkafka/producer/delivery_report.rb
+- lib/rdkafka/producer/partitions_count_cache.rb
 - lib/rdkafka/version.rb
 - rdkafka.gemspec
 - renovate.json
@@ -258,6 +234,7 @@ files:
 - spec/rdkafka/native_kafka_spec.rb
 - spec/rdkafka/producer/delivery_handle_spec.rb
 - spec/rdkafka/producer/delivery_report_spec.rb
+- spec/rdkafka/producer/partitions_count_spec.rb
 - spec/rdkafka/producer_spec.rb
 - spec/spec_helper.rb
 licenses:
@@ -265,10 +242,10 @@ licenses:
 metadata:
   funding_uri: https://karafka.io/#become-pro
   homepage_uri: https://karafka.io
-  changelog_uri: https://github.com/karafka/rdkafka-ruby/blob/main/CHANGELOG.md
+  changelog_uri: https://karafka.io/docs/Changelog-Rdkafka
   bug_tracker_uri: https://github.com/karafka/rdkafka-ruby/issues
   source_code_uri: https://github.com/karafka/rdkafka-ruby
-  documentation_uri: https://github.com/karafka/rdkafka-ruby/blob/main/README.md
+  documentation_uri: https://karafka.io/docs
   rubygems_mfa_required: 'true'
 rdoc_options: []
 require_paths:
@@ -284,7 +261,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.6.2
+rubygems_version: 3.6.7
 specification_version: 4
 summary: The rdkafka gem is a modern Kafka client library for Ruby based on librdkafka.
   It wraps the production-ready C client using the ffi gem and targets Kafka 1.0+
@@ -315,5 +292,6 @@ test_files:
 - spec/rdkafka/native_kafka_spec.rb
 - spec/rdkafka/producer/delivery_handle_spec.rb
 - spec/rdkafka/producer/delivery_report_spec.rb
+- spec/rdkafka/producer/partitions_count_spec.rb
 - spec/rdkafka/producer_spec.rb
 - spec/spec_helper.rb