karafka-rdkafka 0.19.5 → 0.20.0.rc1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: e84a931a800cf4fb0e62f0d15de7f53e5c5845e8edfcd240f1939ec445050bdb
-  data.tar.gz: f12b221a26faa281f4c9c90b2a55ac8ebc623cf1aa882b0ce8e7ae274aa6a122
+  metadata.gz: c5b81585e7271750f4b6c5110df05e25765fd6f86c991ce7f27f3a4714ec94ae
+  data.tar.gz: 387f5d228af380f6be3e4df9e1ea0d8842f4e65450f0d2dfc60ca68df9613a41
 SHA512:
-  metadata.gz: 225e690444b46ea2469f0a92beb7e27cd105c49b1649c022163996fb994ed67c9adac95573bfa96f23134732a3e4d41f5dbffc970bdffd699de664b4b1b89e73
-  data.tar.gz: 1fcb61fd0d7ca98537b59d15235fd84ab202e020828d36cab07b9ecf837eb845fafa7a6624eb760902c5b50050134a30361f16429f2442f43491f76c57bb4340
+  metadata.gz: '0190399ef8742b240a04d4fe55de8263d6b7ff015556ca094227bbf7838ce1d47c7f152e0224bbc9a4ed288651a6a2a4d2ec161b1f8219570f9affdfaa93e1a3'
+  data.tar.gz: 4d2ab1b51e28b07e852de063b3ad163e90a5e7191c70b3b0c7d88591b063fbd3b15f2bee452b6cb8de9a6e1032e633a64f013fd0ff10a0ff5f5f58e3ce1b3c18

data/.github/workflows/ci.yml

@@ -1,4 +1,4 @@
-name: CI
+name: ci
 
 concurrency:
   group: ${{ github.workflow }}-${{ github.ref }}
@@ -51,7 +51,7 @@ jobs:
           docker compose up -d || (sleep 5 && docker compose up -d)
 
       - name: Set up Ruby
-        uses: ruby/setup-ruby@13e7a03dc3ac6c3798f4570bfead2aed4d96abfb # v1.244.0
+        uses: ruby/setup-ruby@ca041f971d66735f3e5ff1e21cc13e2d51e7e535 # v1.233.0
         with:
           ruby-version: ${{matrix.ruby}}
           bundler-cache: true
@@ -86,7 +86,7 @@ jobs:
       - uses: actions/checkout@11bd71901bbe5b1630ceea73d27597364c9af683 # v4.2.2
 
       - name: Set up Ruby
-        uses: ruby/setup-ruby@13e7a03dc3ac6c3798f4570bfead2aed4d96abfb # v1.244.0
+        uses: ruby/setup-ruby@ca041f971d66735f3e5ff1e21cc13e2d51e7e535 # v1.233.0
         with:
           ruby-version: ${{matrix.ruby}}
           bundler-cache: false

data/.ruby-version

@@ -1 +1 @@
-3.4.4
+3.4.3

data/CHANGELOG.md

@@ -1,20 +1,8 @@
 # Rdkafka Changelog
 
-## 0.19.5 (2025-05-30)
-- [Enhancement] Allow for producing to non-existing topics with `key` and `partition_key` present.
-
-## 0.19.4 (2025-05-23)
-- [Change] Move to trusted-publishers and remove signing since no longer needed.
-
-## 0.19.3 (2025-05-23)
-- [Enhancement] Include broker message in the error full message if provided.
-
-## 0.19.2 (2025-05-20)
-- [Enhancement] Replace TTL-based partition count cache with a global cache that reuses `librdkafka` statistics data when possible.
+## 0.20.0 (Unreleased)
+- [Enhancement] Bump librdkafka to 2.10.0
 - [Enhancement] Roll out experimental jruby support.
-- [Fix] Fix issue where post-closed producer C topics refs would not be cleaned.
-- [Fix] Fiber causes Segmentation Fault.
-- [Change] Move to trusted-publishers and remove signing since no longer needed.
 
 ## 0.19.1 (2025-04-07)
 - [Enhancement] Support producing and consuming of headers with mulitple values (KIP-82).

data/README.md

@@ -163,7 +163,9 @@ bundle exec rake produce_messages
 
 | rdkafka-ruby | librdkafka | patches |
 |-|-|-|
-| 0.19.x (2025-01-20) | 2.8.0 (2025-01-07)  | yes |
+| 0.20.0 (Unreleased) | 2.10.0 (2025-04-18) | yes |
+| 0.19.1 (2025-04-07) | 2.8.0 (2025-01-07)  | yes |
+| 0.19.0 (2025-01-20) | 2.8.0 (2025-01-07)  | yes |
 | 0.18.0 (2024-11-26) | 2.6.1 (2024-11-18)  | yes |
 | 0.17.4 (2024-09-02) | 2.5.3 (2024-09-02)  | yes |
 | 0.17.0 (2024-08-01) | 2.5.0 (2024-07-10)  | yes |

data/Rakefile

@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 
+# Rakefile
+
 require 'bundler/gem_tasks'
 require "./lib/rdkafka"
 

data/certs/cert.pem

@@ -0,0 +1,26 @@
+-----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-----

data/docker-compose.yml

@@ -1,7 +1,7 @@
 services:
   kafka:
     container_name: kafka
-    image: confluentinc/cp-kafka:7.9.1
+    image: confluentinc/cp-kafka:7.9.0
 
     ports:
       - 9092:9092

data/karafka-rdkafka.gemspec

@@ -17,6 +17,11 @@ Gem::Specification.new do |gem|
   gem.version = Rdkafka::VERSION
   gem.required_ruby_version = '>= 3.1'
   gem.extensions = %w(ext/Rakefile)
+  gem.cert_chain = %w[certs/cert.pem]
+
+  if $PROGRAM_NAME.end_with?('gem')
+    gem.signing_key = File.expand_path('~/.ssh/gem-private_key.pem')
+  end
 
   gem.add_dependency 'ffi', '~> 1.15'
   gem.add_dependency 'mini_portile2', '~> 2.6'
@@ -32,7 +37,7 @@ Gem::Specification.new do |gem|
   gem.metadata = {
     'funding_uri' => 'https://karafka.io/#become-pro',
     'homepage_uri' => 'https://karafka.io',
-    'changelog_uri' => 'https://karafka.io/docs/Changelog-Karafka-Rdkafka/',
+    'changelog_uri' => 'https://github.com/karafka/karafka-rdkafka/blob/master/CHANGELOG.md',
     'bug_tracker_uri' => 'https://github.com/karafka/karafka-rdkafka/issues',
     'source_code_uri' => 'https://github.com/karafka/karafka-rdkafka',
     'documentation_uri' => 'https://karafka.io/docs',

data/lib/rdkafka/bindings.rb

@@ -35,8 +35,6 @@ module Rdkafka
     RD_KAFKA_OFFSET_STORED    = -1000
     RD_KAFKA_OFFSET_INVALID   = -1001
 
-    EMPTY_HASH = {}.freeze
-
     class SizePtr < FFI::Struct
       layout :value, :size_t
     end
@@ -217,31 +215,9 @@ module Rdkafka
     StatsCallback = FFI::Function.new(
       :int, [:pointer, :string, :int, :pointer]
     ) do |_client_ptr, json, _json_len, _opaque|
+      # Pass the stats hash to callback in config
       if Rdkafka::Config.statistics_callback
         stats = JSON.parse(json)
-
-        # If user requested statistics callbacks, we can use the statistics data to get the
-        # partitions count for each topic when this data is published. That way we do not have
-        # to query this information when user is using `partition_key`. This takes around 0.02ms
-        # every statistics interval period (most likely every 5 seconds) and saves us from making
-        # any queries to the cluster for the partition count.
-        #
-        # One edge case is if user would set the `statistics.interval.ms` much higher than the
-        # default current partition count refresh (30 seconds). This is taken care of as the lack
-        # of reporting to the partitions cache will cause cache expire and blocking refresh.
-        #
-        # If user sets `topic.metadata.refresh.interval.ms` too high this is on the user.
-        #
-        # Since this cache is shared, having few consumers and/or producers in one process will
-        # automatically improve the querying times even with low refresh times.
-        (stats['topics'] || EMPTY_HASH).each do |topic_name, details|
-          partitions_count = details['partitions'].keys.reject { |k| k == '-1' }.size
-
-          next unless partitions_count.positive?
-
-          Rdkafka::Producer.partitions_count_cache.set(topic_name, partitions_count)
-        end
-
         Rdkafka::Config.statistics_callback.call(stats)
       end
 

data/lib/rdkafka/error.rb

@@ -126,14 +126,7 @@ module Rdkafka
                      else
                        ''
                      end
-
-      err_str = Rdkafka::Bindings.rd_kafka_err2str(@rdkafka_response)
-      base = "#{message_prefix_part}#{err_str} (#{code})"
-
-      return base if broker_message.nil?
-      return base if broker_message.empty?
-
-      "#{base}\n#{broker_message}"
+      "#{message_prefix_part}#{Rdkafka::Bindings.rd_kafka_err2str(@rdkafka_response)} (#{code})"
     end
 
     # Whether this error indicates the partition is EOF.

data/lib/rdkafka/native_kafka.rb

@@ -126,13 +126,9 @@ module Rdkafka
         # and would continue to run, trying to destroy inner twice
         return unless @inner
 
-        yield if block_given?
-
         Rdkafka::Bindings.rd_kafka_destroy(@inner)
         @inner = nil
         @opaque = nil
-        @poll_mutex.unlock
-        @poll_mutex = nil
       end
     end
   end

data/lib/rdkafka/producer.rb

@@ -6,31 +6,13 @@ module Rdkafka
     include Helpers::Time
     include Helpers::OAuth
 
-    # @private
-    @@partitions_count_cache = PartitionsCountCache.new
-
-    # Global (process wide) partitions cache. We use it to store number of topics partitions,
-    # either from the librdkafka statistics (if enabled) or via direct inline calls every now and
-    # then. Since the partitions count can only grow and should be same for all consumers and
-    # producers, we can use a global cache as long as we ensure that updates only move up.
-    #
-    # @note It is critical to remember, that not all users may have statistics callbacks enabled,
-    #   hence we should not make assumption that this cache is always updated from the stats.
-    #
-    # @return [Rdkafka::Producer::PartitionsCountCache]
-    def self.partitions_count_cache
-      @@partitions_count_cache
-    end
-
-    # @param partitions_count_cache [Rdkafka::Producer::PartitionsCountCache]
-    def self.partitions_count_cache=(partitions_count_cache)
-      @@partitions_count_cache = partitions_count_cache
-    end
+    # Cache partitions count for 30 seconds
+    PARTITIONS_COUNT_TTL = 30
 
     # Empty hash used as a default
     EMPTY_HASH = {}.freeze
 
-    private_constant :EMPTY_HASH
+    private_constant :PARTITIONS_COUNT_TTL, :EMPTY_HASH
 
     # Raised when there was a critical issue when invoking rd_kafka_topic_new
     # This is a temporary solution until https://github.com/karafka/rdkafka-ruby/issues/451 is
@@ -61,6 +43,25 @@ module Rdkafka
 
       # Makes sure, that native kafka gets closed before it gets GCed by Ruby
       ObjectSpace.define_finalizer(self, native_kafka.finalizer)
+
+      @_partitions_count_cache = Hash.new do |cache, topic|
+        topic_metadata = nil
+
+        @native_kafka.with_inner do |inner|
+          topic_metadata = ::Rdkafka::Metadata.new(inner, topic).topics&.first
+        end
+
+        partition_count = topic_metadata ? topic_metadata[:partition_count] : -1
+
+        # This approach caches the failure to fetch only for 1 second. This will make sure, that
+        # we do not cache the failure for too long but also "buys" us a bit of time in case there
+        # would be issues in the cluster so we won't overaload it with consecutive requests
+        cache[topic] = if partition_count.positive?
+                         [monotonic_now, partition_count]
+                       else
+                         [monotonic_now - PARTITIONS_COUNT_TTL + 5, partition_count]
+                       end
+      end
     end
 
     # Sets alternative set of configuration details that can be set per topic
@@ -283,31 +284,18 @@ module Rdkafka
     # @note If 'allow.auto.create.topics' is set to true in the broker, the topic will be
     #   auto-created after returning nil.
     #
-    # @note We cache the partition count for a given topic for given time. If statistics are
-    #   enabled for any producer or consumer, it will take precedence over per instance fetching.
-    #
+    # @note We cache the partition count for a given topic for given time.
     #   This prevents us in case someone uses `partition_key` from querying for the count with
-    #   each message. Instead we query at most once every 30 seconds at most if we have a valid
-    #   partition count or every 5 seconds in case we were not able to obtain number of partitions.
+    #   each message. Instead we query once every 30 seconds at most if we have a valid partition
+    #   count or every 5 seconds in case we were not able to obtain number of partitions
     def partition_count(topic)
       closed_producer_check(__method__)
 
-      self.class.partitions_count_cache.get(topic) do
-        topic_metadata = nil
-
-        @native_kafka.with_inner do |inner|
-          topic_metadata = ::Rdkafka::Metadata.new(inner, topic).topics&.first
-        end
-
-        topic_metadata ? topic_metadata[:partition_count] : -1
+      @_partitions_count_cache.delete_if do |_, cached|
+        monotonic_now - cached.first > PARTITIONS_COUNT_TTL
       end
-    rescue Rdkafka::RdkafkaError => e
-      # If the topic does not exist, it will be created or if not allowed another error will be
-      # raised. We here return -1 so this can happen without early error happening on metadata
-      # discovery.
-      return -1 if e.code == :unknown_topic_or_part
 
-      raise(e)
+      @_partitions_count_cache[topic].last
     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.

data/lib/rdkafka/version.rb

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 
 module Rdkafka
-  VERSION = "0.19.5"
-  LIBRDKAFKA_VERSION = "2.8.0"
-  LIBRDKAFKA_SOURCE_SHA256 = "5bd1c46f63265f31c6bfcedcde78703f77d28238eadf23821c2b43fc30be3e25"
+  VERSION = "0.20.0.rc1"
+  LIBRDKAFKA_VERSION = "2.10.0"
+  LIBRDKAFKA_SOURCE_SHA256 = "004b1cc2685d1d6d416b90b426a0a9d27327a214c6b807df6f9ea5887346ba3a"
 end

data/lib/rdkafka.rb

@@ -42,7 +42,6 @@ require "rdkafka/consumer/topic_partition_list"
 require "rdkafka/error"
 require "rdkafka/metadata"
 require "rdkafka/native_kafka"
-require "rdkafka/producer/partitions_count_cache"
 require "rdkafka/producer"
 require "rdkafka/producer/delivery_handle"
 require "rdkafka/producer/delivery_report"

data/spec/rdkafka/admin_spec.rb

@@ -34,7 +34,7 @@ describe Rdkafka::Admin do
   describe '#describe_errors' do
     let(:errors) { admin.class.describe_errors }
 
-    it { expect(errors.size).to eq(170) }
+    it { expect(errors.size).to eq(172) }
     it { expect(errors[-184]).to eq(code: -184, description: 'Local: Queue full', name: '_QUEUE_FULL') }
     it { expect(errors[21]).to eq(code: 21, description: 'Broker: Invalid required acks value', name: 'INVALID_REQUIRED_ACKS') }
   end

data/spec/rdkafka/consumer_spec.rb

@@ -842,9 +842,9 @@ describe Rdkafka::Consumer do
       missing_topic = SecureRandom.uuid
       consumer.subscribe(missing_topic)
 
-      expect {
-        consumer.poll(1_000)
-      }.to raise_error Rdkafka::RdkafkaError, /Subscribed topic not available: #{missing_topic}/
+      # @note it used to raise "Subscribed topic not available" in previous librdkafka versions
+      #   but this behaviour has been changed
+      expect { consumer.poll(1_000) }.not_to raise_error
     end
   end
 

data/spec/rdkafka/producer_spec.rb

@@ -364,48 +364,6 @@ describe Rdkafka::Producer do
     expect(message.key).to eq "key utf8"
   end
 
-  it "should produce a message to a non-existing topic with key and partition key" do
-    new_topic = "it-#{SecureRandom.uuid}"
-
-    handle = producer.produce(
-      # Needs to be a new topic each time
-      topic:   new_topic,
-      payload: "payload",
-      key:     "key",
-      partition_key: "partition_key",
-      label:   "label"
-    )
-
-    # Should be pending at first
-    expect(handle.pending?).to be true
-    expect(handle.label).to eq "label"
-
-    # Check delivery handle and report
-    report = handle.wait(max_wait_timeout: 5)
-    expect(handle.pending?).to be false
-    expect(report).not_to be_nil
-    expect(report.partition).to eq 0
-    expect(report.offset).to be >= 0
-    expect(report.label).to eq "label"
-
-    # Flush and close producer
-    producer.flush
-    producer.close
-
-    # Consume message and verify its content
-    message = wait_for_message(
-      topic: new_topic,
-      delivery_report: report,
-      consumer: consumer
-    )
-    expect(message.partition).to eq 0
-    expect(message.payload).to eq "payload"
-    expect(message.key).to eq "key"
-    # Since api.version.request is on by default we will get
-    # the message creation timestamp if it's not set.
-    expect(message.timestamp).to be_within(10).of(Time.now)
-  end
-
   context "timestamp" do
     it "should raise a type error if not nil, integer or time" do
       expect {
@@ -679,25 +637,6 @@ describe Rdkafka::Producer do
     end
   end
 
-  context "when topic does not exist and allow.auto.create.topics is false" do
-    let(:producer) do
-      rdkafka_producer_config(
-        "bootstrap.servers": "localhost:9092",
-        "message.timeout.ms": 100,
-        "allow.auto.create.topics": false
-      ).producer
-    end
-
-    it "should contain the error in the response when not deliverable" do
-      handler = producer.produce(topic: "it-#{SecureRandom.uuid}", payload: nil, label: 'na')
-      # Wait for the async callbacks and delivery registry to update
-      sleep(2)
-      expect(handler.create_result.error).to be_a(Rdkafka::RdkafkaError)
-      expect(handler.create_result.error.code).to eq(:msg_timed_out)
-      expect(handler.create_result.label).to eq('na')
-    end
-  end
-
   describe '#partition_count' do
     it { expect(producer.partition_count('example_topic')).to eq(1) }
 
@@ -715,11 +654,12 @@ describe Rdkafka::Producer do
 
     context 'when the partition count value was cached but time expired' do
       before do
-        ::Rdkafka::Producer.partitions_count_cache = Rdkafka::Producer::PartitionsCountCache.new
+        allow(::Process).to receive(:clock_gettime).and_return(0, 30.02)
+        producer.partition_count('example_topic')
         allow(::Rdkafka::Metadata).to receive(:new).and_call_original
       end
 
-      it 'expect to query it again' do
+      it 'expect not to query it again' do
         producer.partition_count('example_topic')
         expect(::Rdkafka::Metadata).to have_received(:new)
       end
@@ -1102,133 +1042,4 @@ describe Rdkafka::Producer do
       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,9 +18,6 @@ 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
 
@@ -128,12 +125,6 @@ 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
     {