karafka-rdkafka 0.27.2-aarch64-linux-gnu → 0.28.0-aarch64-linux-gnu

data/lib/rdkafka/metadata.rb

@@ -23,12 +23,55 @@ module Rdkafka
     # @param timeout_ms [Integer] timeout in milliseconds
     # @raise [RdkafkaError] when metadata fetch fails
     def initialize(native_client, topic_name = nil, timeout_ms = Defaults::METADATA_TIMEOUT_MS)
-      attempt ||= 0
-      attempt += 1
-
-      native_topic = if topic_name
-        Rdkafka::Bindings.rd_kafka_topic_new(native_client, topic_name, nil)
+      attempt = 0
+      deadline = ::Process.clock_gettime(::Process::CLOCK_MONOTONIC) +
+        Defaults::METADATA_RETRY_BUDGET_MS / 1_000.0
+
+      begin
+        attempt += 1
+        fetch_metadata(native_client, topic_name, timeout_ms)
+      rescue ::Rdkafka::RdkafkaError => e
+        raise unless RETRIED_ERRORS.include?(e.code)
+        raise if attempt > Defaults::METADATA_MAX_RETRIES
+
+        # Stop once the wall-clock retry budget is spent, but only after at least
+        # METADATA_MIN_ATTEMPTS tries so a slow broker (whose requests each consume the full
+        # timeout) still gets a few tries rather than being cut off after one or two.
+        raise if attempt >= Defaults::METADATA_MIN_ATTEMPTS &&
+          ::Process.clock_gettime(::Process::CLOCK_MONOTONIC) >= deadline
+
+        # Exponential backoff between attempts, capped so a long retry sequence cannot block for
+        # minutes. The request timeout (`timeout_ms`) is intentionally left unchanged: it used to be
+        # overwritten with the backoff value, which shrank the first retries below the configured
+        # timeout (near-guaranteeing another timeout) and then inflated later ones to ~100s.
+        backoff_ms = [
+          (2**attempt) * Defaults::METADATA_RETRY_BACKOFF_BASE_MS,
+          Defaults::METADATA_RETRY_BACKOFF_MAX_MS
+        ].min
+
+        sleep(backoff_ms / 1_000.0)
+
+        retry
       end
+    end
+
+    private
+
+    # Performs a single metadata fetch attempt and frees its native resources before returning.
+    #
+    # This is intentionally separate from the retry loop in {#initialize}: `retry` restarts the
+    # `begin` block without running its `ensure`, so cleaning up here (rather than in an `ensure`
+    # around the loop) guarantees every attempt destroys its own native topic handle and metadata
+    # struct instead of leaking all but the last one.
+    #
+    # @param native_client [FFI::Pointer] pointer to the native Kafka client
+    # @param topic_name [String, nil] specific topic to fetch metadata for, or nil for all topics
+    # @param timeout_ms [Integer] timeout in milliseconds
+    def fetch_metadata(native_client, topic_name, timeout_ms)
+      native_topic = nil
+      metadata_ptr = nil
+
+      native_topic = Rdkafka::Bindings.rd_kafka_topic_new(native_client, topic_name, nil) if topic_name
 
       ptr = FFI::MemoryPointer.new(:pointer)
 
@@ -41,24 +84,16 @@ module Rdkafka
 
       Rdkafka::RdkafkaError.validate!(result)
 
-      metadata_from_native(ptr.read_pointer)
-    rescue ::Rdkafka::RdkafkaError => e
-      raise unless RETRIED_ERRORS.include?(e.code)
-      raise if attempt > Defaults::METADATA_MAX_RETRIES
+      # rd_kafka_metadata only allocates the struct on success, so we read the pointer to destroy
+      # only after validate! has confirmed the call succeeded.
+      metadata_ptr = ptr.read_pointer
 
-      backoff_factor = 2**attempt
-      timeout_ms = backoff_factor * Defaults::METADATA_RETRY_BACKOFF_BASE_MS
-
-      sleep(timeout_ms / 1_000.0)
-
-      retry
+      metadata_from_native(metadata_ptr)
     ensure
-      Rdkafka::Bindings.rd_kafka_topic_destroy(native_topic) if topic_name
-      Rdkafka::Bindings.rd_kafka_metadata_destroy(ptr.read_pointer)
+      Rdkafka::Bindings.rd_kafka_topic_destroy(native_topic) if native_topic
+      Rdkafka::Bindings.rd_kafka_metadata_destroy(metadata_ptr) if metadata_ptr && !metadata_ptr.null?
     end
 
-    private
-
     # Extracts metadata from native pointer
     # @param ptr [FFI::Pointer] pointer to native metadata
     def metadata_from_native(ptr)
@@ -134,6 +169,36 @@ module Rdkafka
         :replicas, :pointer,
         :in_sync_replica_brokers, :int,
         :isrs, :pointer
+
+      # The base `#to_h` skips FFI pointer members, which would drop the replica and in-sync
+      # replica assignments entirely. We dereference those pointers here so the partition hash
+      # exposes the broker ids backing the partition (needed e.g. to plan replication changes).
+      #
+      # @return [Hash{Symbol => Integer, Array<Integer>}] partition metadata:
+      #   * +:partition_id+ (Integer) - partition id
+      #   * +:leader+ (Integer) - broker id of the partition leader
+      #   * +:replica_count+ (Integer) - number of assigned replicas
+      #   * +:in_sync_replica_brokers+ (Integer) - number of in-sync replicas
+      #   * +:replicas+ (Array<Integer>) - broker ids of the assigned replicas
+      #   * +:isrs+ (Array<Integer>) - broker ids of the in-sync replicas
+      def to_h
+        super.merge(
+          replicas: read_broker_ids(self[:replicas], self[:replica_count]),
+          isrs: read_broker_ids(self[:isrs], self[:in_sync_replica_brokers])
+        )
+      end
+
+      private
+
+      # Reads `count` broker ids (int32) from a replicas/isrs pointer.
+      # @param pointer [FFI::Pointer] pointer to the broker ids array
+      # @param count [Integer] number of broker ids to read
+      # @return [Array<Integer>] broker ids (empty when there are none)
+      def read_broker_ids(pointer, count)
+        return [] if count.zero? || pointer.null?
+
+        pointer.read_array_of_int32(count)
+      end
     end
   end
 end

data/lib/rdkafka/producer/delivery_handle.rb

@@ -8,14 +8,14 @@ module Rdkafka
       layout :pending, :bool,
         :response, :int,
         :partition, :int,
-        :offset, :int64,
-        :topic_name, :pointer
+        :offset, :int64
 
       # @return [Object, nil] label set during message production or nil by default
       attr_accessor :label
 
       # @return [String] topic where we are trying to send the message
-      # We use this instead of reading from `topic_name` pointer to save on memory allocations
+      # Set in `#produce`, where the topic is known upfront. Keeping it as a Ruby attribute
+      # spares a per-message native string copy in the delivery callback.
       attr_accessor :topic
 
       # @return [String] the name of the operation (e.g. "delivery")

data/lib/rdkafka/producer/partitions_count_cache.rb

@@ -37,12 +37,11 @@ module Rdkafka
     #    contention in multi-threaded environments while ensuring data consistency.
     #
     # 6. Topic recreation handling
-    #    If a topic is deleted and recreated with fewer partitions, the cache will continue to
-    #    report the higher count until either the TTL expires or the process is restarted. This
-    #    design choice simplifies the implementation while relying on librdkafka's error handling
-    #    for edge cases. In production environments, topic recreation with different partition
-    #    counts is typically accompanied by application restarts to handle structural changes.
-    #    This also aligns with the previous cache implementation.
+    #    If a topic is deleted and recreated with fewer partitions, the cache keeps reporting the
+    #    higher count only until the entry's TTL expires. The first refresh after expiry performs
+    #    an authoritative metadata read and adopts the lower count. Within the TTL window a lower
+    #    value is still ignored, so a transient or racy lower read cannot clobber a correct higher
+    #    count.
     class PartitionsCountCache
       include Helpers::Time
 
@@ -91,28 +90,14 @@ module Rdkafka
         current_info = @counts[topic]
 
         if current_info.nil? || expired?(current_info[0])
+          # The cached entry is missing or expired, so the block performs an authoritative metadata
+          # read. We hand it to `set`, which adopts a higher count always and a lower count once the
+          # entry has expired (e.g. the topic was recreated with fewer partitions). We then return
+          # whatever `set` settled on so a concurrent refresh that wrote a higher value still wins.
           new_count = yield
+          set(topic, new_count)
 
-          if current_info.nil?
-            # No existing data, create a new entry with mutex
-            set(topic, new_count)
-
-            return new_count
-          else
-            current_count = current_info[1]
-
-            if new_count > current_count
-              # Higher value needs mutex to update both timestamp and count
-              set(topic, new_count)
-
-              return new_count
-            else
-              # Same or lower value, just update timestamp without mutex
-              refresh_timestamp(topic)
-
-              return current_count
-            end
-          end
+          return @counts[topic][1]
         end
 
         current_info[1]
@@ -133,8 +118,11 @@ module Rdkafka
         # First check outside mutex to avoid unnecessary locking
         current_info = @counts[topic]
 
-        # For lower values, we don't update count but might need to refresh timestamp
-        if current_info && new_count < current_info[1]
+        # Within the TTL window a lower value is treated as a stale/racy read and ignored, since
+        # partition counts only grow during normal operation. Once the entry has expired a lower
+        # value is an authoritative refresh (e.g. the topic was recreated with fewer partitions),
+        # so we fall through and adopt it below.
+        if current_info && new_count < current_info[1] && !expired?(current_info[0])
           refresh_timestamp(topic)
 
           return
@@ -148,17 +136,15 @@ module Rdkafka
           if current_info.nil?
             # Create new entry
             @counts[topic] = [monotonic_now_ms, new_count]
+          elsif new_count > current_info[1] || expired?(current_info[0])
+            # A higher count always wins; a lower count is accepted only when the existing entry
+            # has expired, so a concurrent fresh higher value (which reset the timestamp) is never
+            # clobbered by a stale lower one.
+            current_info[0] = monotonic_now_ms
+            current_info[1] = new_count
           else
-            current_count = current_info[1]
-
-            if new_count > current_count
-              # Update to higher count value
-              current_info[0] = monotonic_now_ms
-              current_info[1] = new_count
-            else
-              # Same or lower count, update timestamp only
-              current_info[0] = monotonic_now_ms
-            end
+            # Same or lower count within the TTL window: refresh the timestamp only
+            current_info[0] = monotonic_now_ms
           end
         end
       end

data/lib/rdkafka/producer.rb

@@ -5,6 +5,7 @@ module Rdkafka
   class Producer
     include Helpers::Time
     include Helpers::OAuth
+    include Helpers::Metadata
 
     # @private
     @@partitions_count_cache = PartitionsCountCache.new
@@ -94,6 +95,12 @@ module Rdkafka
               )
 
               unless result == :config_ok
+                # rd_kafka_topic_new has not been called yet, so librdkafka has not taken
+                # ownership of the config. Destroy it ourselves before raising, otherwise the
+                # partially built rd_kafka_topic_conf_t leaks. (On the rd_kafka_topic_new path
+                # librdkafka frees the conf on both success and failure, so we never destroy it
+                # there.)
+                Rdkafka::Bindings.rd_kafka_topic_conf_destroy(topic_config)
                 raise Config::ConfigError.new(error_buffer.read_string)
               end
             end
@@ -388,9 +395,11 @@ module Rdkafka
     # @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.
     #
-    #   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.
+    #   This prevents us, in case someone uses `partition_key`, from querying for the count with
+    #   each message. A missing topic (`unknown_topic_or_part`) is cached as
+    #   `RD_KAFKA_PARTITION_UA` too, so producing to a not-yet-created topic does not run a
+    #   blocking metadata query on every message; the cache TTL still bounds how long that result
+    #   is reused before we look again.
     def partition_count(topic)
       closed_producer_check(__method__)
 
@@ -402,14 +411,15 @@ module Rdkafka
         end
 
         topic_metadata ? topic_metadata[:partition_count] : Rdkafka::Bindings::RD_KAFKA_PARTITION_UA
+      rescue Rdkafka::RdkafkaError => e
+        # A missing topic is an expected, cacheable outcome (the topic may be auto-created on
+        # produce, or simply not exist yet). Returning RD_KAFKA_PARTITION_UA from inside the block
+        # caches it, so we don't re-run a blocking metadata query on every produce(partition_key:)
+        # to that topic. Anything else is a real error and is re-raised.
+        raise(e) unless e.code == :unknown_topic_or_part
+
+        Rdkafka::Bindings::RD_KAFKA_PARTITION_UA
       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 RD_KAFKA_PARTITION_UA so this can happen without early error
-      # happening on metadata discovery.
-      return Rdkafka::Bindings::RD_KAFKA_PARTITION_UA if e.code == :unknown_topic_or_part
-
-      raise(e)
     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.
@@ -511,24 +521,39 @@ module Rdkafka
       delivery_handle[:offset] = Rdkafka::Bindings::RD_KAFKA_PARTITION_UA
       DeliveryHandle.register(delivery_handle)
 
-      args = [
-        :int, Rdkafka::Bindings::RD_KAFKA_VTYPE_RKT, :pointer, topic_ref,
-        :int, Rdkafka::Bindings::RD_KAFKA_VTYPE_MSGFLAGS, :int, Rdkafka::Bindings::RD_KAFKA_MSG_F_COPY,
-        :int, Rdkafka::Bindings::RD_KAFKA_VTYPE_VALUE, :buffer_in, payload, :size_t, payload_size,
-        :int, Rdkafka::Bindings::RD_KAFKA_VTYPE_KEY, :buffer_in, key, :size_t, key_size,
-        :int, Rdkafka::Bindings::RD_KAFKA_VTYPE_PARTITION, :int32, partition,
-        :int, Rdkafka::Bindings::RD_KAFKA_VTYPE_TIMESTAMP, :int64, raw_timestamp,
-        :int, Rdkafka::Bindings::RD_KAFKA_VTYPE_OPAQUE, :pointer, delivery_handle
-      ]
-
-      if headers && !headers.empty?
-        headers.each do |key0, value0|
-          key = key0.to_s
-          case value0
-          when Array
-            # Handle array of values per KIP-82
-            value0.each do |v|
-              value = v.to_s
+      # Everything between registration and the successful return must remove the handle from the
+      # process-global registry if it raises. Otherwise a failure after registration (a concurrent
+      # close making `with_inner` raise `ClosedInnerError`, or a header value whose `#to_s` raises)
+      # would orphan the handle in the registry forever, since nothing else will ever resolve it.
+      begin
+        args = [
+          :int, Rdkafka::Bindings::RD_KAFKA_VTYPE_RKT, :pointer, topic_ref,
+          :int, Rdkafka::Bindings::RD_KAFKA_VTYPE_MSGFLAGS, :int, Rdkafka::Bindings::RD_KAFKA_MSG_F_COPY,
+          :int, Rdkafka::Bindings::RD_KAFKA_VTYPE_VALUE, :buffer_in, payload, :size_t, payload_size,
+          :int, Rdkafka::Bindings::RD_KAFKA_VTYPE_KEY, :buffer_in, key, :size_t, key_size,
+          :int, Rdkafka::Bindings::RD_KAFKA_VTYPE_PARTITION, :int32, partition,
+          :int, Rdkafka::Bindings::RD_KAFKA_VTYPE_TIMESTAMP, :int64, raw_timestamp,
+          :int, Rdkafka::Bindings::RD_KAFKA_VTYPE_OPAQUE, :pointer, delivery_handle
+        ]
+
+        if headers && !headers.empty?
+          headers.each do |key0, value0|
+            key = key0.to_s
+            case value0
+            when Array
+              # Handle array of values per KIP-82
+              value0.each do |v|
+                value = v.to_s
+                args.push(
+                  :int, Rdkafka::Bindings::RD_KAFKA_VTYPE_HEADER,
+                  :string, key,
+                  :pointer, value,
+                  :size_t, value.bytesize
+                )
+              end
+            else
+              # Handle single value
+              value = value0.to_s
               args.push(
                 :int, Rdkafka::Bindings::RD_KAFKA_VTYPE_HEADER,
                 :string, key,
@@ -536,36 +561,31 @@ module Rdkafka
                 :size_t, value.bytesize
               )
             end
-          else
-            # Handle single value
-            value = value0.to_s
-            args.push(
-              :int, Rdkafka::Bindings::RD_KAFKA_VTYPE_HEADER,
-              :string, key,
-              :pointer, value,
-              :size_t, value.bytesize
-            )
           end
         end
-      end
 
-      args.push(:int, Rdkafka::Bindings::RD_KAFKA_VTYPE_END)
+        args.push(:int, Rdkafka::Bindings::RD_KAFKA_VTYPE_END)
 
-      # Produce the message
-      response = @native_kafka.with_inner do |inner|
-        Rdkafka::Bindings.rd_kafka_producev(
-          inner,
-          *args
-        )
-      end
+        # Produce the message
+        response = @native_kafka.with_inner do |inner|
+          Rdkafka::Bindings.rd_kafka_producev(
+            inner,
+            *args
+          )
+        end
 
-      # Raise error if the produce call was not successful
-      if response != Rdkafka::Bindings::RD_KAFKA_RESP_ERR_NO_ERROR
+        # Raise error if the produce call was not successful. On a successful enqueue the handle
+        # stays registered on purpose: the delivery callback resolves and removes it once librdkafka
+        # reports the delivery.
+        if response != Rdkafka::Bindings::RD_KAFKA_RESP_ERR_NO_ERROR
+          @native_kafka.with_inner do |inner|
+            Rdkafka::RdkafkaError.validate!(response, client_ptr: inner)
+          end
+        end
+      rescue Exception
         DeliveryHandle.remove(delivery_handle.to_ptr.address)
 
-        @native_kafka.with_inner do |inner|
-          Rdkafka::RdkafkaError.validate!(response, client_ptr: inner)
-        end
+        raise
       end
 
       delivery_handle
@@ -607,5 +627,6 @@ module Rdkafka
     def closed_producer_check(method)
       raise Rdkafka::ClosedProducerError.new(method) if closed?
     end
+    alias_method :closed_check, :closed_producer_check
   end
 end

data/lib/rdkafka/version.rb

@@ -2,9 +2,9 @@
 
 module Rdkafka
   # Current rdkafka-ruby gem version
-  VERSION = "0.27.2"
+  VERSION = "0.28.0"
   # Target librdkafka version to be used
-  LIBRDKAFKA_VERSION = "2.14.1"
+  LIBRDKAFKA_VERSION = "2.14.2"
   # SHA256 hash of the librdkafka source tarball for verification
-  LIBRDKAFKA_SOURCE_SHA256 = "bb246e754dee3560e9b42bf4e844dc05de4b146a3cae937e36301ffacdc456e7"
+  LIBRDKAFKA_SOURCE_SHA256 = "d7eec9c31c817fa44402f679c252dfbf97e4c338a849a25c3579a31fd127beb8"
 end

data/lib/rdkafka.rb

@@ -9,6 +9,8 @@ require "rdkafka/version"
 require "rdkafka/defaults"
 require "rdkafka/helpers/time"
 require "rdkafka/helpers/oauth"
+require "rdkafka/helpers/metadata"
+require "rdkafka/helpers/list_offsets"
 require "rdkafka/abstract_handle"
 require "rdkafka/admin"
 require "rdkafka/admin/create_topic_handle"
@@ -36,6 +38,17 @@ require "rdkafka/admin/config_binding_result"
 require "rdkafka/admin/config_resource_binding_result"
 require "rdkafka/bindings"
 require "rdkafka/callbacks"
+require "rdkafka/callbacks/base_handler"
+require "rdkafka/callbacks/create_topic_handler"
+require "rdkafka/callbacks/delete_topic_handler"
+require "rdkafka/callbacks/create_partitions_handler"
+require "rdkafka/callbacks/delete_groups_handler"
+require "rdkafka/callbacks/create_acl_handler"
+require "rdkafka/callbacks/delete_acl_handler"
+require "rdkafka/callbacks/describe_acl_handler"
+require "rdkafka/callbacks/describe_configs_handler"
+require "rdkafka/callbacks/incremental_alter_configs_handler"
+require "rdkafka/callbacks/list_offsets_handler"
 require "rdkafka/config"
 require "rdkafka/consumer"
 require "rdkafka/consumer/headers"

data/package-lock.json

@@ -286,9 +286,9 @@
       }
     },
     "node_modules/smol-toml": {
-      "version": "1.6.1",
-      "resolved": "https://registry.npmjs.org/smol-toml/-/smol-toml-1.6.1.tgz",
-      "integrity": "sha512-dWUG8F5sIIARXih1DTaQAX4SsiTXhInKf1buxdY9DIg4ZYPZK5nGM1VRIYmEbDbsHt7USo99xSLFu5Q1IqTmsg==",
+      "version": "1.7.0",
+      "resolved": "https://registry.npmjs.org/smol-toml/-/smol-toml-1.7.0.tgz",
+      "integrity": "sha512-aqVvWoyO21L23mb+drl4RmMXbf6N7FdHjAhTRA9ZBL7apWBgfWC16KjrASI+1p9GAroljyMHj6fK67i0UiTNvQ==",
       "dev": true,
       "license": "BSD-3-Clause",
       "engines": {
@@ -312,9 +312,9 @@
       }
     },
     "node_modules/yaml": {
-      "version": "2.8.4",
-      "resolved": "https://registry.npmjs.org/yaml/-/yaml-2.8.4.tgz",
-      "integrity": "sha512-ml/JPOj9fOQK8RNnWojA67GbZ0ApXAUlN2UQclwv2eVgTgn7O9gg9o7paZWKMp4g0H3nTLtS9LVzhkpOFIKzog==",
+      "version": "2.9.0",
+      "resolved": "https://registry.npmjs.org/yaml/-/yaml-2.9.0.tgz",
+      "integrity": "sha512-2AvhNX3mb8zd6Zy7INTtSpl1F15HW6Wnqj0srWlkKLcpYl/gMIMJiyuGq2KeI2YFxUPjdlB+3Lc10seMLtL4cA==",
       "dev": true,
       "license": "ISC",
       "bin": {

data/renovate.json

@@ -87,12 +87,22 @@
       ],
       "groupName": "ruby setup",
       "internalChecksFilter": "strict"
+    },
+    {
+      "description": "Let setup-ruby pass age gate before ruby so it is ready when the group PR is created",
+      "matchPackageNames": [
+        "ruby/setup-ruby"
+      ],
+      "minimumReleaseAge": "5 days"
     }
   ],
   "labels": [
     "dependencies"
   ],
   "lockFileMaintenance": {
-    "enabled": true
+    "enabled": true,
+    "schedule": [
+      "before 4am on the first day of the month"
+    ]
   }
 }

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: karafka-rdkafka
 version: !ruby/object:Gem::Version
-  version: 0.27.2
+  version: 0.28.0
 platform: aarch64-linux-gnu
 authors:
 - Thijs Cadier
@@ -88,9 +88,6 @@ extensions: []
 extra_rdoc_files: []
 files:
 - CHANGELOG.md
-- Gemfile
-- Gemfile.lint
-- Gemfile.lint.lock
 - MIT-LICENSE
 - README.md
 - Rakefile
@@ -127,6 +124,17 @@ files:
 - lib/rdkafka/admin/list_offsets_report.rb
 - lib/rdkafka/bindings.rb
 - lib/rdkafka/callbacks.rb
+- lib/rdkafka/callbacks/base_handler.rb
+- lib/rdkafka/callbacks/create_acl_handler.rb
+- lib/rdkafka/callbacks/create_partitions_handler.rb
+- lib/rdkafka/callbacks/create_topic_handler.rb
+- lib/rdkafka/callbacks/delete_acl_handler.rb
+- lib/rdkafka/callbacks/delete_groups_handler.rb
+- lib/rdkafka/callbacks/delete_topic_handler.rb
+- lib/rdkafka/callbacks/describe_acl_handler.rb
+- lib/rdkafka/callbacks/describe_configs_handler.rb
+- lib/rdkafka/callbacks/incremental_alter_configs_handler.rb
+- lib/rdkafka/callbacks/list_offsets_handler.rb
 - lib/rdkafka/config.rb
 - lib/rdkafka/consumer.rb
 - lib/rdkafka/consumer/headers.rb
@@ -135,6 +143,8 @@ files:
 - lib/rdkafka/consumer/topic_partition_list.rb
 - lib/rdkafka/defaults.rb
 - lib/rdkafka/error.rb
+- lib/rdkafka/helpers/list_offsets.rb
+- lib/rdkafka/helpers/metadata.rb
 - lib/rdkafka/helpers/oauth.rb
 - lib/rdkafka/helpers/time.rb
 - lib/rdkafka/metadata.rb

data/Gemfile

@@ -1,13 +0,0 @@
-# frozen_string_literal: true
-
-source "https://rubygems.org"
-
-gemspec
-
-group :development do
-  gem "ostruct"
-  gem "pry"
-  gem "rspec"
-  gem "simplecov"
-  gem "warning"
-end

data/Gemfile.lint

@@ -1,14 +0,0 @@
-# frozen_string_literal: true
-
-source "https://rubygems.org"
-
-# Documentation linting
-gem "yard-lint"
-
-# Code style (StandardRB via RuboCop)
-gem "standard"
-gem "standard-performance"
-gem "rubocop-performance"
-gem "rubocop-rspec"
-gem "standard-rspec"
-gem "rubocop-thread_safety"