rdkafka 0.28.0-aarch64-linux-gnu → 0.29.1-aarch64-linux-gnu

data/lib/rdkafka/admin/list_consumer_groups_handle.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+module Rdkafka
+  class Admin
+    # Handle for list consumer groups operation
+    class ListConsumerGroupsHandle < AbstractHandle
+      layout :pending, :bool,
+        :response, :int
+
+      # @return [String] the name of the operation
+      def operation_name
+        "list consumer groups"
+      end
+
+      # @return [ListConsumerGroupsReport] report prepared by the background event callback, with
+      #   the listed consumer groups.
+      def create_result
+        prepared_result
+      end
+
+      # Raises an error if the operation failed
+      # @raise [RdkafkaError]
+      def raise_error
+        raise RdkafkaError.new(
+          self[:response],
+          broker_message: broker_message
+        )
+      end
+    end
+  end
+end

data/lib/rdkafka/admin/list_consumer_groups_report.rb

@@ -0,0 +1,83 @@
+# frozen_string_literal: true
+
+module Rdkafka
+  class Admin
+    # Report for list consumer groups operation result
+    class ListConsumerGroupsReport
+      # Consumer groups listed cluster-wide. Each entry is a hash with:
+      #   - `:group_id` [String] the consumer group id
+      #   - `:is_simple_consumer_group` [Boolean] `true` for a "simple" consumer group - one that
+      #     assigns partitions manually (via `assign`) and uses Kafka only for offset storage,
+      #     rather than joining the group-management protocol and letting Kafka assign partitions
+      #     and rebalance automatically (`subscribe`). Simple groups have no members from the
+      #     broker's point of view, so they never rebalance.
+      #   - `:state` [Integer] the group state as a `Bindings::RD_KAFKA_CONSUMER_GROUP_STATE_*`
+      #     code, one of: `RD_KAFKA_CONSUMER_GROUP_STATE_UNKNOWN`,
+      #     `RD_KAFKA_CONSUMER_GROUP_STATE_PREPARING_REBALANCE`,
+      #     `RD_KAFKA_CONSUMER_GROUP_STATE_COMPLETING_REBALANCE`,
+      #     `RD_KAFKA_CONSUMER_GROUP_STATE_STABLE`, `RD_KAFKA_CONSUMER_GROUP_STATE_DEAD`,
+      #     `RD_KAFKA_CONSUMER_GROUP_STATE_EMPTY`
+      #   - `:state_name` [String] human-readable name of that state (e.g. `"Stable"`, `"Empty"`)
+      # @return [Array<Hash>]
+      attr_reader :groups
+
+      # Per-broker errors reported alongside the (partial) group listing. `ListConsumerGroups`
+      # fans out to every broker and returns valid groups and errors separately, so a broker
+      # being unreachable does not discard the groups the reachable brokers returned.
+      # @return [Array<RdkafkaError>]
+      attr_reader :errors
+
+      # @param result_ptr [FFI::Pointer] pointer to the `rd_kafka_ListConsumerGroups_result_t`
+      def initialize(result_ptr)
+        @groups = []
+        @errors = []
+
+        return if result_ptr.null?
+
+        extract_groups(result_ptr)
+        extract_errors(result_ptr)
+      end
+
+      private
+
+      # @param result_ptr [FFI::Pointer] pointer to the result
+      def extract_groups(result_ptr)
+        count_ptr = FFI::MemoryPointer.new(:size_t)
+        array_ptr = Bindings.rd_kafka_ListConsumerGroups_result_valid(result_ptr, count_ptr)
+
+        return if array_ptr.null?
+
+        array_ptr.read_array_of_pointer(count_ptr.read(:size_t)).each do |listing_ptr|
+          state = Bindings.rd_kafka_ConsumerGroupListing_state(listing_ptr)
+          group_id_ptr = Bindings.rd_kafka_ConsumerGroupListing_group_id(listing_ptr)
+          state_name_ptr = Bindings.rd_kafka_consumer_group_state_name(state)
+
+          @groups << {
+            group_id: group_id_ptr.null? ? nil : group_id_ptr.read_string,
+            is_simple_consumer_group:
+              Bindings.rd_kafka_ConsumerGroupListing_is_simple_consumer_group(listing_ptr) != 0,
+            state: state,
+            state_name: state_name_ptr.null? ? nil : state_name_ptr.read_string
+          }
+        end
+      end
+
+      # @param result_ptr [FFI::Pointer] pointer to the result
+      def extract_errors(result_ptr)
+        count_ptr = FFI::MemoryPointer.new(:size_t)
+        array_ptr = Bindings.rd_kafka_ListConsumerGroups_result_errors(result_ptr, count_ptr)
+
+        return if array_ptr.null?
+
+        array_ptr.read_array_of_pointer(count_ptr.read(:size_t)).each do |error_ptr|
+          string_ptr = Bindings.rd_kafka_error_string(error_ptr)
+
+          @errors << RdkafkaError.new(
+            Bindings.rd_kafka_error_code(error_ptr),
+            broker_message: string_ptr.null? ? nil : string_ptr.read_string
+          )
+        end
+      end
+    end
+  end
+end

data/lib/rdkafka/admin/list_offsets_handle.rb

@@ -5,22 +5,17 @@ module Rdkafka
     # Handle for list offsets operation
     class ListOffsetsHandle < AbstractHandle
       layout :pending, :bool,
-        :response, :int,
-        :response_string, :pointer,
-        :result_infos, :pointer,
-        :result_count, :int
+        :response, :int
 
       # @return [String] the name of the operation.
       def operation_name
         "list offsets"
       end
 
-      # @return [ListOffsetsReport] instance with partition offset information.
+      # @return [ListOffsetsReport] report prepared by the background event callback, with
+      #   partition offset information.
       def create_result
-        ListOffsetsReport.new(
-          result_infos: self[:result_infos],
-          result_count: self[:result_count]
-        )
+        prepared_result
       end
 
       # Raises an error if the operation failed
@@ -28,7 +23,7 @@ module Rdkafka
       def raise_error
         raise RdkafkaError.new(
           self[:response],
-          broker_message: self[:response_string].read_string
+          broker_message: broker_message
         )
       end
     end

data/lib/rdkafka/admin/list_offsets_report.rb

@@ -36,7 +36,7 @@ module Rdkafka
 
       # Validates the partition result and raises an error if invalid
       # @param result_info_ptr [FFI::Pointer] pointer to the result info
-      # @raise [RdkafkaError] when the partition has an error
+      # @raise [RdkafkaError] when the partition has an error, naming the failing partition
       def validate!(result_info_ptr)
         tp_ptr = Bindings.rd_kafka_ListOffsetsResultInfo_topic_partition(result_info_ptr)
         tp = Bindings::TopicPartition.new(tp_ptr)
@@ -44,7 +44,10 @@ module Rdkafka
 
         return if code.zero?
 
-        raise RdkafkaError.new(code)
+        raise RdkafkaError.new(
+          code,
+          "Error querying offsets for partition #{tp[:partition]} of '#{tp[:topic]}'"
+        )
       end
     end
   end

data/lib/rdkafka/admin.rb

@@ -4,6 +4,8 @@ module Rdkafka
   # Admin client for Kafka administrative operations
   class Admin
     include Helpers::OAuth
+    include Helpers::Metadata
+    include Helpers::ListOffsets
 
     class << self
       # Allows us to retrieve librdkafka errors with descriptions
@@ -106,10 +108,6 @@ module Rdkafka
     # @return [nil]
     # @raise [Rdkafka::ClosedAdminError] if called on a closed admin client
     #
-    # @note This method holds the inner lock until the queue is empty or `:stop` is returned.
-    #   Other admin operations will wait until this method returns.
-    # @note This method is thread-safe as it uses @native_kafka.with_inner synchronization
-    #
     # @example Drain all pending events
     #   admin.events_poll_nb_each { |_count| }
     #
@@ -118,6 +116,9 @@ module Rdkafka
     #   admin.events_poll_nb_each do |_count|
     #     :stop if monotonic_now >= deadline
     #   end
+    # @note This method holds the inner lock until the queue is empty or `:stop` is returned.
+    #   Other admin operations will wait until this method returns.
+    # @note This method is thread-safe as it uses @native_kafka.with_inner synchronization
     def events_poll_nb_each
       closed_admin_check(__method__)
 
@@ -130,19 +131,6 @@ module Rdkafka
       end
     end
 
-    # Performs the metadata request using admin
-    #
-    # @param topic_name [String, nil] metadat about particular topic or all if nil
-    # @param timeout_ms [Integer] metadata request timeout
-    # @return [Metadata] requested metadata
-    def metadata(topic_name = nil, timeout_ms = Defaults::METADATA_TIMEOUT_MS)
-      closed_admin_check(__method__)
-
-      @native_kafka.with_inner do |inner|
-        Metadata.new(inner, topic_name, timeout_ms)
-      end
-    end
-
     # Close this admin instance
     def close
       return if closed?
@@ -258,7 +246,7 @@ module Rdkafka
         Rdkafka::Bindings.rd_kafka_queue_get_background(inner)
       end
       if queue_ptr.null?
-        Rdkafka::Bindings.rd_kafka_DeleteTopic_destroy(delete_topic_ptr)
+        Rdkafka::Bindings.rd_kafka_DeleteGroup_destroy(delete_groups_ptr)
         raise Rdkafka::Config::ConfigError.new("rd_kafka_queue_get_background was NULL")
       end
 
@@ -294,6 +282,172 @@ module Rdkafka
       delete_groups_handle
     end
 
+    # Deletes all messages in the given partitions up to (but not including) the given offset.
+    #
+    # The programmatic equivalent of `kafka-delete-records.sh`. Useful for GDPR/right-to-erasure
+    # compliance, clearing out poison messages, or retention cleanup outside of the configured
+    # time/size-based retention policy.
+    #
+    # @param topic_partition_offsets [Hash{String => Array<Hash>}] hash mapping topic names to
+    #   arrays of partition delete specifications. Each specification is a hash with:
+    #   - `:partition` [Integer] partition number
+    #   - `:offset` [Symbol, Integer] delete all messages before this offset (exclusive) - an
+    #     integer offset, or `:end` to delete all data currently in the partition
+    #
+    # @return [DeleteRecordsHandle] handle that can be used to wait for the result
+    # @raise [RdkafkaError] when deleting records fails
+    #
+    # @example Delete all messages before offset 100 in one partition, and all data in another
+    #   report = admin.delete_records(
+    #     "my_topic" => [
+    #       { partition: 0, offset: 100 },
+    #       { partition: 1, offset: :end }
+    #     ]
+    #   ).wait(max_wait_timeout_ms: 15_000)
+    #
+    #   report.offsets.to_h
+    #   # => { "my_topic" => [#<Partition @partition=0, @offset=100, @err=0>, ...] }
+    def delete_records(topic_partition_offsets)
+      closed_admin_check(__method__)
+
+      parsed = topic_partition_offsets.flat_map do |topic, partitions|
+        partitions.map do |spec|
+          offset = spec.fetch(:offset)
+
+          native_offset = case offset
+          when :end then Rdkafka::Bindings::RD_KAFKA_OFFSET_END
+          when Integer then offset
+          else
+            raise ArgumentError, "Unknown offset specification: #{offset.inspect}"
+          end
+
+          [topic, spec.fetch(:partition), native_offset]
+        end
+      end
+
+      tpl = Rdkafka::Bindings.rd_kafka_topic_partition_list_new(parsed.size)
+
+      parsed.each do |topic, partition, native_offset|
+        Rdkafka::Bindings.rd_kafka_topic_partition_list_add(tpl, topic, partition)
+        Rdkafka::Bindings.rd_kafka_topic_partition_list_set_offset(tpl, topic, partition, native_offset)
+      end
+
+      # rd_kafka_DeleteRecords_new copies the tpl it is given, so it does not need to (and must
+      # not) outlive this call - it is destroyed below, independently of the wrapping
+      # DeleteRecords_t object.
+      delete_records_ptr = Rdkafka::Bindings.rd_kafka_DeleteRecords_new(tpl)
+      Rdkafka::Bindings.rd_kafka_topic_partition_list_destroy(tpl)
+
+      pointer_array = [delete_records_ptr]
+      records_array_ptr = FFI::MemoryPointer.new(:pointer)
+      records_array_ptr.write_array_of_pointer(pointer_array)
+
+      # Get a pointer to the queue that our request will be enqueued on
+      queue_ptr = @native_kafka.with_inner do |inner|
+        Rdkafka::Bindings.rd_kafka_queue_get_background(inner)
+      end
+      if queue_ptr.null?
+        Rdkafka::Bindings.rd_kafka_DeleteRecords_destroy(delete_records_ptr)
+        raise Rdkafka::Config::ConfigError.new("rd_kafka_queue_get_background was NULL")
+      end
+
+      # Create and register the handle we will return to the caller
+      handle = DeleteRecordsHandle.new
+      handle[:pending] = true
+      handle[:response] = Rdkafka::Bindings::RD_KAFKA_PARTITION_UA
+      DeleteRecordsHandle.register(handle)
+
+      admin_options_ptr = @native_kafka.with_inner do |inner|
+        Rdkafka::Bindings.rd_kafka_AdminOptions_new(inner, Rdkafka::Bindings::RD_KAFKA_ADMIN_OP_DELETERECORDS)
+      end
+      Rdkafka::Bindings.rd_kafka_AdminOptions_set_opaque(admin_options_ptr, handle.to_ptr)
+
+      begin
+        @native_kafka.with_inner do |inner|
+          Rdkafka::Bindings.rd_kafka_DeleteRecords(
+            inner,
+            records_array_ptr,
+            1,
+            admin_options_ptr,
+            queue_ptr
+          )
+        end
+      rescue Exception
+        DeleteRecordsHandle.remove(handle.to_ptr.address)
+        raise
+      ensure
+        Rdkafka::Bindings.rd_kafka_AdminOptions_destroy(admin_options_ptr)
+        Rdkafka::Bindings.rd_kafka_queue_destroy(queue_ptr)
+        Rdkafka::Bindings.rd_kafka_DeleteRecords_destroy(delete_records_ptr)
+      end
+
+      handle
+    end
+
+    # Lists consumer groups cluster-wide.
+    #
+    # librdkafka issues a single `ListConsumerGroups` request that is fanned out to every broker
+    # internally, so the result covers all consumer groups in the cluster, not only those
+    # coordinated by the connected broker.
+    #
+    # @return [ListConsumerGroupsHandle] handle that can be used to wait for the result
+    # @raise [RdkafkaError] when listing the consumer groups fails
+    #
+    # @example List every consumer group in the cluster and print its name and attributes
+    #   report = admin.list_consumer_groups.wait(max_wait_timeout_ms: 15_000)
+    #
+    #   report.groups.each do |group|
+    #     puts "#{group[:group_id]} - #{group[:state_name]} " \
+    #          "(simple: #{group[:is_simple_consumer_group]})"
+    #   end
+    #
+    #   # Any brokers that could not be reached are reported separately
+    #   report.errors.each { |error| warn "partial listing error: #{error.message}" }
+    def list_consumer_groups
+      closed_admin_check(__method__)
+
+      # Get a pointer to the queue that our request will be enqueued on
+      queue_ptr = @native_kafka.with_inner do |inner|
+        Rdkafka::Bindings.rd_kafka_queue_get_background(inner)
+      end
+
+      if queue_ptr.null?
+        raise Rdkafka::Config::ConfigError.new("rd_kafka_queue_get_background was NULL")
+      end
+
+      # Create and register the handle we will return to the caller
+      handle = ListConsumerGroupsHandle.new
+      handle[:pending] = true
+      handle[:response] = Rdkafka::Bindings::RD_KAFKA_PARTITION_UA
+      ListConsumerGroupsHandle.register(handle)
+
+      admin_options_ptr = @native_kafka.with_inner do |inner|
+        Rdkafka::Bindings.rd_kafka_AdminOptions_new(
+          inner,
+          Rdkafka::Bindings::RD_KAFKA_ADMIN_OP_LISTCONSUMERGROUPS
+        )
+      end
+      Rdkafka::Bindings.rd_kafka_AdminOptions_set_opaque(admin_options_ptr, handle.to_ptr)
+
+      begin
+        @native_kafka.with_inner do |inner|
+          Rdkafka::Bindings.rd_kafka_ListConsumerGroups(
+            inner,
+            admin_options_ptr,
+            queue_ptr
+          )
+        end
+      rescue Exception
+        ListConsumerGroupsHandle.remove(handle.to_ptr.address)
+        raise
+      ensure
+        Rdkafka::Bindings.rd_kafka_AdminOptions_destroy(admin_options_ptr)
+        Rdkafka::Bindings.rd_kafka_queue_destroy(queue_ptr)
+      end
+
+      handle
+    end
+
     # Deletes the named topic
     #
     # @param topic_name [String] name of the topic to delete
@@ -356,7 +510,8 @@ module Rdkafka
     #
     # @param topic_name [String] name of the topic
     # @param partition_count [Integer] how many partitions we want to end up with for given topic
-    # @return [CreatePartitionsHandle] Create partitions handle that can be used to wait for the result
+    # @return [CreatePartitionsHandle] Create partitions handle that can be used to wait for the
+    #   result
     # @raise [ConfigError] When the partition count or replication factor are out of valid range
     # @raise [RdkafkaError] When the topic name is invalid or the topic already exists
     # @raise [RdkafkaError] When the topic configuration is invalid
@@ -445,7 +600,8 @@ module Rdkafka
     # @param permission_type [Integer] rd_kafka_AclPermissionType_t value:
     #   - RD_KAFKA_ACL_PERMISSION_TYPE_DENY  = 2
     #   - RD_KAFKA_ACL_PERMISSION_TYPE_ALLOW = 3
-    # @return [CreateAclHandle] Create acl handle that can be used to wait for the result of creating the acl
+    # @return [CreateAclHandle] Create acl handle that can be used to wait for the result of
+    #   creating the acl
     # @raise [RdkafkaError]
     def create_acl(resource_type:, resource_name:, resource_pattern_type:, principal:, host:, operation:, permission_type:)
       closed_admin_check(__method__)
@@ -546,7 +702,8 @@ module Rdkafka
     # @param permission_type [Integer] rd_kafka_AclPermissionType_t value:
     #   - RD_KAFKA_ACL_PERMISSION_TYPE_DENY  = 2
     #   - RD_KAFKA_ACL_PERMISSION_TYPE_ALLOW = 3
-    # @return [DeleteAclHandle] Delete acl handle that can be used to wait for the result of deleting the acl
+    # @return [DeleteAclHandle] Delete acl handle that can be used to wait for the result of
+    #   deleting the acl
     # @raise [RdkafkaError]
     def delete_acl(resource_type:, resource_name:, resource_pattern_type:, principal:, host:, operation:, permission_type:)
       closed_admin_check(__method__)
@@ -581,7 +738,7 @@ module Rdkafka
       end
 
       if queue_ptr.null?
-        Rdkafka::Bindings.rd_kafka_AclBinding_destroy(new_acl_ptr)
+        Rdkafka::Bindings.rd_kafka_AclBinding_destroy(delete_acl_ptr)
         raise Rdkafka::Config::ConfigError.new("rd_kafka_queue_get_background was NULL")
       end
 
@@ -649,7 +806,8 @@ module Rdkafka
     # @param permission_type [Integer] rd_kafka_AclPermissionType_t value:
     #   - RD_KAFKA_ACL_PERMISSION_TYPE_DENY  = 2
     #   - RD_KAFKA_ACL_PERMISSION_TYPE_ALLOW = 3
-    # @return [DescribeAclHandle] Describe acl handle that can be used to wait for the result of fetching acls
+    # @return [DescribeAclHandle] Describe acl handle that can be used to wait for the result of
+    #   fetching acls
     # @raise [RdkafkaError]
     def describe_acl(resource_type:, resource_name:, resource_pattern_type:, principal:, host:, operation:, permission_type:)
       closed_admin_check(__method__)
@@ -677,7 +835,7 @@ module Rdkafka
       end
 
       if queue_ptr.null?
-        Rdkafka::Bindings.rd_kafka_AclBinding_destroy(new_acl_ptr)
+        Rdkafka::Bindings.rd_kafka_AclBinding_destroy(describe_acl_ptr)
         raise Rdkafka::Config::ConfigError.new("rd_kafka_queue_get_background was NULL")
       end
 
@@ -728,6 +886,14 @@ module Rdkafka
     def describe_configs(resources)
       closed_admin_check(__method__)
 
+      # Parse user input before allocating any native resources or registering the handle, so a
+      # missing :resource_type / :resource_name key raises with nothing to clean up. Previously the
+      # KeyError leaked the background queue, the AdminOptions, the registered handle and any
+      # ConfigResources already built.
+      parsed_resources = resources.map do |resource_details|
+        [resource_details.fetch(:resource_type), resource_details.fetch(:resource_name)]
+      end
+
       handle = DescribeConfigsHandle.new
       handle[:pending] = true
       handle[:response] = Rdkafka::Bindings::RD_KAFKA_PARTITION_UA
@@ -750,12 +916,10 @@ module Rdkafka
       DescribeConfigsHandle.register(handle)
       Rdkafka::Bindings.rd_kafka_AdminOptions_set_opaque(admin_options_ptr, handle.to_ptr)
 
-      pointer_array = resources.map do |resource_details|
+      pointer_array = parsed_resources.map do |resource_type, resource_name|
         Rdkafka::Bindings.rd_kafka_ConfigResource_new(
-          resource_details.fetch(:resource_type),
-          FFI::MemoryPointer.from_string(
-            resource_details.fetch(:resource_name)
-          )
+          resource_type,
+          FFI::MemoryPointer.from_string(resource_name)
         )
       end
 
@@ -806,6 +970,19 @@ module Rdkafka
     def incremental_alter_configs(resources_with_configs)
       closed_admin_check(__method__)
 
+      # Parse user input before allocating native resources or registering the handle, so a missing
+      # key raises with nothing to clean up. Previously the KeyError leaked the background queue,
+      # the AdminOptions, the registered handle and any ConfigResources already built.
+      parsed_resources = resources_with_configs.map do |resource_details|
+        [
+          resource_details.fetch(:resource_type),
+          resource_details.fetch(:resource_name),
+          resource_details.fetch(:configs).map do |config|
+            [config.fetch(:name), config.fetch(:op_type), config.fetch(:value)]
+          end
+        ]
+      end
+
       handle = IncrementalAlterConfigsHandle.new
       handle[:pending] = true
       handle[:response] = Rdkafka::Bindings::RD_KAFKA_PARTITION_UA
@@ -828,23 +1005,39 @@ module Rdkafka
       IncrementalAlterConfigsHandle.register(handle)
       Rdkafka::Bindings.rd_kafka_AdminOptions_set_opaque(admin_options_ptr, handle.to_ptr)
 
-      # Tu poprawnie tworzyc
-      pointer_array = resources_with_configs.map do |resource_details|
+      add_error = nil
+
+      pointer_array = parsed_resources.map do |resource_type, resource_name, configs|
         # First build the appropriate resource representation
         resource_ptr = Rdkafka::Bindings.rd_kafka_ConfigResource_new(
-          resource_details.fetch(:resource_type),
-          FFI::MemoryPointer.from_string(
-            resource_details.fetch(:resource_name)
-          )
+          resource_type,
+          FFI::MemoryPointer.from_string(resource_name)
         )
 
-        resource_details.fetch(:configs).each do |config|
-          Bindings.rd_kafka_ConfigResource_add_incremental_config(
+        configs.each do |name, op_type, value|
+          # rd_kafka_ConfigResource_add_incremental_config returns a non-NULL rd_kafka_error_t for
+          # an invalid op_type, an empty/nil name, or a nil value on a non-delete op. The result
+          # used to be ignored: the entry was silently dropped, the alter request still reported
+          # success, and the error object leaked. Capture the first error (always destroying the
+          # native error object) and raise it below, before the request is sent.
+          error_ptr = Bindings.rd_kafka_ConfigResource_add_incremental_config(
             resource_ptr,
-            config.fetch(:name),
-            config.fetch(:op_type),
-            config.fetch(:value)
+            name,
+            op_type,
+            value
           )
+
+          unless error_ptr.null?
+            code = Rdkafka::Bindings.rd_kafka_error_code(error_ptr)
+            Rdkafka::Bindings.rd_kafka_error_destroy(error_ptr)
+
+            unless code == Rdkafka::Bindings::RD_KAFKA_RESP_ERR_NO_ERROR
+              add_error ||= Rdkafka::RdkafkaError.new(
+                code,
+                "rd_kafka_ConfigResource_add_incremental_config"
+              )
+            end
+          end
         end
 
         resource_ptr
@@ -854,6 +1047,10 @@ module Rdkafka
       configs_array_ptr.write_array_of_pointer(pointer_array)
 
       begin
+        # Raise only after the full array is built so the ensure below frees every ConfigResource
+        # we created, and before the request is sent so a rejected entry can't report success.
+        raise add_error if add_error
+
         @native_kafka.with_inner do |inner|
           Rdkafka::Bindings.rd_kafka_IncrementalAlterConfigs(
             inner,
@@ -882,111 +1079,6 @@ module Rdkafka
       handle
     end
 
-    # Queries partition offsets by specification (earliest, latest, max_timestamp, or by
-    # timestamp) without requiring a consumer group.
-    #
-    # @param topic_partition_offsets [Hash{String => Array<Hash>}] hash mapping topic names to
-    #   arrays of partition offset specifications. Each specification is a hash with:
-    #   - `:partition` [Integer] partition number
-    #   - `:offset` [Symbol, Integer] offset specification - `:earliest`, `:latest`,
-    #     `:max_timestamp`, or an integer timestamp in milliseconds
-    # @param isolation_level [Integer, nil] optional isolation level:
-    #   - `RD_KAFKA_ISOLATION_LEVEL_READ_UNCOMMITTED` (0) - default
-    #   - `RD_KAFKA_ISOLATION_LEVEL_READ_COMMITTED` (1)
-    #
-    # @return [ListOffsetsHandle] handle that can be used to wait for the result
-    #
-    # @raise [ClosedAdminError] when the admin is closed
-    # @raise [ConfigError] when the background queue is unavailable
-    #
-    # @example Query earliest and latest offsets
-    #   handle = admin.list_offsets(
-    #     { "my_topic" => [
-    #       { partition: 0, offset: :earliest },
-    #       { partition: 1, offset: :latest }
-    #     ] }
-    #   )
-    #   report = handle.wait(max_wait_timeout_ms: 15_000)
-    #   report.offsets
-    #   # => [{ topic: "my_topic", partition: 0, offset: 0, ... }, ...]
-    def list_offsets(topic_partition_offsets, isolation_level: nil)
-      closed_admin_check(__method__)
-
-      # Count total partitions for pre-allocation
-      total = topic_partition_offsets.sum { |_, partitions| partitions.size }
-
-      # Build native topic partition list
-      tpl = Rdkafka::Bindings.rd_kafka_topic_partition_list_new(total)
-
-      topic_partition_offsets.each do |topic, partitions|
-        partitions.each do |spec|
-          partition = spec.fetch(:partition)
-          offset = spec.fetch(:offset)
-
-          native_offset = case offset
-          when :earliest then Rdkafka::Bindings::RD_KAFKA_OFFSET_SPEC_EARLIEST
-          when :latest then Rdkafka::Bindings::RD_KAFKA_OFFSET_SPEC_LATEST
-          when :max_timestamp then Rdkafka::Bindings::RD_KAFKA_OFFSET_SPEC_MAX_TIMESTAMP
-          when Integer then offset
-          else
-            raise ArgumentError, "Unknown offset specification: #{offset.inspect}"
-          end
-
-          Rdkafka::Bindings.rd_kafka_topic_partition_list_add(tpl, topic, partition)
-          Rdkafka::Bindings.rd_kafka_topic_partition_list_set_offset(tpl, topic, partition, native_offset)
-        end
-      end
-
-      # Get a pointer to the queue that our request will be enqueued on
-      queue_ptr = @native_kafka.with_inner do |inner|
-        Rdkafka::Bindings.rd_kafka_queue_get_background(inner)
-      end
-
-      if queue_ptr.null?
-        Rdkafka::Bindings.rd_kafka_topic_partition_list_destroy(tpl)
-        raise Rdkafka::Config::ConfigError.new("rd_kafka_queue_get_background was NULL")
-      end
-
-      # Create and register the handle we will return to the caller
-      handle = ListOffsetsHandle.new
-      handle[:pending] = true
-      handle[:response] = Rdkafka::Bindings::RD_KAFKA_PARTITION_UA
-
-      admin_options_ptr = @native_kafka.with_inner do |inner|
-        Rdkafka::Bindings.rd_kafka_AdminOptions_new(
-          inner,
-          Rdkafka::Bindings::RD_KAFKA_ADMIN_OP_LISTOFFSETS
-        )
-      end
-
-      if isolation_level
-        Rdkafka::Bindings.rd_kafka_AdminOptions_set_isolation_level(admin_options_ptr, isolation_level)
-      end
-
-      ListOffsetsHandle.register(handle)
-      Rdkafka::Bindings.rd_kafka_AdminOptions_set_opaque(admin_options_ptr, handle.to_ptr)
-
-      begin
-        @native_kafka.with_inner do |inner|
-          Rdkafka::Bindings.rd_kafka_ListOffsets(
-            inner,
-            tpl,
-            admin_options_ptr,
-            queue_ptr
-          )
-        end
-      rescue Exception
-        ListOffsetsHandle.remove(handle.to_ptr.address)
-        raise
-      ensure
-        Rdkafka::Bindings.rd_kafka_AdminOptions_destroy(admin_options_ptr)
-        Rdkafka::Bindings.rd_kafka_queue_destroy(queue_ptr)
-        Rdkafka::Bindings.rd_kafka_topic_partition_list_destroy(tpl)
-      end
-
-      handle
-    end
-
     private
 
     # Checks if the admin is closed and raises an error if so
@@ -995,5 +1087,6 @@ module Rdkafka
     def closed_admin_check(method)
       raise Rdkafka::ClosedAdminError.new(method) if closed?
     end
+    alias_method :closed_check, :closed_admin_check
   end
 end