rdkafka 0.28.0 → 0.29.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 0c811b180607c5cfb8ac4b81046d47f0f1a3cf86d00485ed924484993a2c2888
-  data.tar.gz: 4b541fbec39c2cbdd14d419cfad1cc6af2f85c0d3b19d5a7dd7f8d52069b932d
+  metadata.gz: 9df14d82195673f4747cc9a5d20eeb705a547295b1fa25f6554a5f9fac415ff0
+  data.tar.gz: d98858ef1d0c6694acd2de1726e0727a17aae1694adf2d75ee9890bdf8608d57
 SHA512:
-  metadata.gz: add2edda65ab8a0600faef30b0e25f4a80f8324c0809ee807baf6b90d0125d2ef404b99efaefd1c3bc8dcafb71b1fd86592e7d608657b7d1c3750b636f666c48
-  data.tar.gz: f8c1def0cf19994dc964f388fd334ac932c30ae080d6f3c834c4f72b4dc4373f035337d9905f8c03b56c291dd24e6760167ac3107ad7d302e5512e163765c102
+  metadata.gz: 82715ad307088ce3559789b9445c968fb1dcbfa2e87ba70b8e90c786ff92066c37497b8592153e8512ed297706a8499d38e2c04754129390665478a3174bcf0e
+  data.tar.gz: 00fd0221b7afde5cf110437d3b83f7672b820b3ebc596d2ad7126c248f31bb89b35d29ced75c24da0a17af2828a2fc4f7feb4397cdcfe6d04bf78882f2ee02b6

data/CHANGELOG.md

@@ -1,5 +1,47 @@
 # Rdkafka Changelog
 
+## 0.29.1 (2026-09-04)
+- [Enhancement] Add `Admin#delete_records` to delete all messages in a partition up to a given offset.
+- [Enhancement] Add `Admin#list_consumer_groups` to list the cluster's consumer groups.
+- [Enhancement] Name the failing topic and partition in the `RdkafkaError` raised for per-partition `list_offsets` errors.
+- [Enhancement] Add `Consumer#list_offsets` to query partition offsets on an existing consumer handle without opening a dedicated admin connection.
+- [Fix] Make `NativeKafka#close` fork-aware so a forked child no longer segfaults on exit.
+- [Fix] Stabilize the `to_native_tpl` leak integration spec.
+- [Fix] Stabilize the flaky partitions count cache statistics spec.
+
+## 0.29.0 (2026-07-10)
+- [Enhancement] Bump librdkafka to `2.14.2`
+- [Enhancement] Add `Consumer#metadata` and `Producer#metadata`, mirroring `Admin#metadata`, so cluster/topic metadata can be fetched from an existing consumer or producer handle without opening a dedicated admin connection.
+- [Enhancement] Support offset-commit metadata: `Consumer#store_offset(message, metadata)` stores an optional metadata string alongside the offset, `Consumer::Partition#metadata` exposes it, and `TopicPartitionList` marshals it to and from the native list (read back via `Consumer#committed`).
+- [Enhancement] Expose `replicas` and `isrs` (in-sync replica broker ids) on each partition in topic metadata; both were previously dropped from the `Metadata#topics` partition hashes.
+- [Enhancement] Extract the admin background-event result handlers into one class per operation under `lib/rdkafka/callbacks/`. Internal reorganization with no API or behavior change.
+- [Enhancement] Reuse per-thread scratch pointers in `Consumer::Headers.from_native`, removing the per-message native allocations from the consumer hot path.
+- [Enhancement] Remove the unused `DeliveryHandle` `:topic_name` struct field and its per-message allocation. Use `DeliveryHandle#topic` or `DeliveryReport#topic_name`, both unchanged.
+- [Fix] Cache the partition count for a missing topic, so `produce` with a `partition_key` to a missing topic no longer re-runs a blocking metadata query on every message.
+- [Fix] Let `PartitionsCountCache` adopt a lower partition count once the cached entry has expired, so a topic recreated with fewer partitions no longer fails `produce` until process restart.
+- [Fix] Surface per-message build errors inline in `Consumer#poll_batch`/`#poll_batch_nb` instead of discarding the batch, preserving the messages that built successfully.
+- [Fix] Bound the `Metadata` retry loop by a ~5s wall-clock budget with a floor of 3 attempts, cap the backoff at 1s, and stop overwriting the request timeout with the backoff value, which could block a synchronous fetch for minutes.
+- [Fix] Synchronize `AbstractHandle::REGISTRY` mutations with a mutex, which could otherwise lose a write on JRuby and leave a handle unregistered or leaked.
+- [Fix] Fix the NULL background-queue cleanup branches in `Admin#delete_group`, `Admin#delete_acl` and `Admin#describe_acl`, which raised a `NameError` and leaked the native request object instead of raising `ConfigError`.
+- [Fix] Actually populate `ConfigBindingResult#synonyms`. The synonym loop built the synonym binding objects and discarded them, so `#synonyms` was always an empty array; they are now appended.
+- [Fix] Stop leaking the native `rd_kafka_topic_conf_t` in `Producer#set_topic_config` when a per-topic config value is rejected.
+- [Fix] Add the missing `closed_consumer_check` to `Consumer#position`, the only public consumer method without one; calling it on a closed consumer now raises a consistent `ClosedConsumerError` instead of failing deeper in the call.
+- [Fix] Guard the OAuthBearer token refresh callback against a NULL client pointer before calling `rd_kafka_name` on it.
+- [Fix] Make the `Consumer` GC finalizer close the consumer and destroy its consumer queue, not just the native client, preventing a hang or leak when a consumer is collected without an explicit `close`.
+- [Fix] Free the librdkafka-allocated string in `Consumer#cluster_id` and `Consumer#member_id`, and fix the `rd_kafka_clusterid` arity. `Consumer#cluster_id` now accepts a `timeout_ms`.
+- [Fix] Attach `rd_kafka_query_watermark_offsets` with `blocking: true` so it releases the GVL; it previously froze every other Ruby thread for up to `timeout_ms`.
+- [Fix] Stop leaking the native `rd_kafka_conf_t` when client creation fails, a multi-KB leak per failed attempt for supervisors retrying on transient SASL/SSL misconfiguration.
+- [Fix] Stop `Metadata` from leaking the native metadata struct on every retried fetch; each attempt now frees its own native resources.
+- [Fix] Stop `Producer#produce` from orphaning the delivery handle in the process-global registry when it fails after registering it.
+- [Fix] Guard the message delivery callback so a raising user `delivery_callback` can no longer leave the handle locked or crash the producer; exceptions are now logged and swallowed.
+- [Fix] Stop `describe_configs`, `incremental_alter_configs` and `list_offsets` from leaking handles and native resources when their arguments are rejected; all three now validate input before allocating.
+- [Fix] Destroy the native topic-partition list in `TopicPartitionList#to_native_tpl` when population fails partway (e.g. an invalid partition). The caller-owned list was leaked on any exception mid-build; it is now destroyed before the error propagates.
+- [Fix] Raise instead of silently dropping a rejected `incremental_alter_configs` entry, which previously left the alter request reporting success.
+- [Fix] Allocate the admin result-count out-parameter as `:size_t` instead of `:int32`, fixing a 4-byte overflow on every admin result parse.
+- [Fix] Stabilize the flaky `Consumer#lag` "calculates the consumer lag" spec on overloaded CI.
+- [Fix] Resolve admin operation handles from the event error when an operation fails at the operation level (e.g. brokers unreachable), instead of blocking until `wait` timed out and discarding the real error.
+- [Fix] Destroy admin API background events after processing; they were never destroyed, so every admin operation leaked its whole result event. The internal FFI struct fields on admin handles were removed as part of this - use `handle.wait` and the returned report objects, whose interfaces are unchanged.
+
 ## 0.28.0 (2026-06-03)
 - [Enhancement] Bump librdkafka to `2.14.1`
 - [Enhancement] Replace version-gated `Warning[:performance]` with dynamic `Warning.categories` opt-in in spec helper so new Ruby warning categories are automatically enabled without manual updates.

data/README.md

@@ -1,6 +1,6 @@
 # Rdkafka
 
-[![Build Status](https://github.com/karafka/rdkafka-ruby/actions/workflows/ci_linux_ubuntu_x86_64_gnu.yml/badge.svg)](https://github.com/karafka/rdkafka-ruby/actions/workflows/ci_linux_x86_64_gnu.yml)
+[![Build Status](https://github.com/karafka/rdkafka-ruby/actions/workflows/ci_linux_ubuntu_x86_64_gnu.yml/badge.svg)](https://github.com/karafka/rdkafka-ruby/actions/workflows/ci_linux_ubuntu_x86_64_gnu.yml)
 [![Gem Version](https://badge.fury.io/rb/rdkafka.svg)](https://badge.fury.io/rb/rdkafka)
 [![Join the chat at https://slack.karafka.io](https://raw.githubusercontent.com/karafka/misc/master/slack.svg)](https://slack.karafka.io)
 
@@ -163,6 +163,7 @@ bundle exec rake produce_messages
 
 | rdkafka-ruby | librdkafka | patches |
 |-|-|-|
+| 0.29.x (2026-07-10) | 2.14.2 (2026-06-03) | yes |
 | 0.28.x (2026-06-03) | 2.14.1 (2026-04-15) | yes |
 | 0.27.x (2026-05-07) | 2.14.0 (2026-04-01) | yes |
 | 0.26.x (2026-03-30) | 2.13.2 (2026-03-02) | yes |
@@ -173,7 +174,7 @@ bundle exec rake produce_messages
 | 0.21.x (2025-02-13) | 2.8.0 (2025-01-07)  | yes |
 | 0.20.0 (2025-01-07) | 2.6.1 (2024-11-18)  | yes |
 | 0.19.0 (2024-10-01) | 2.5.3 (2024-09-02)  | yes |
-| 0.18.0 (2024-09-02) | 2.5.0 (2024-06-10)  | yes |
+| 0.18.0 (2024-09-02) | 2.5.0 (2024-07-10)  | yes |
 | 0.17.0 (2024-08-03) | 2.4.0 (2024-05-07)  | no  |
 | 0.16.0 (2024-06-13) | 2.3.0 (2023-10-25)  | no  |
 | 0.15.0 (2023-12-03) | 2.3.0 (2023-10-25)  | no  |

data/bin/verify_kafka_warnings

@@ -4,6 +4,11 @@
 # Only specified warnings are allowed, all others should trigger failure
 
 allowed_patterns=(
+  # Enabling share groups (KIP-932) requires "share" in group.coordinator.rebalance.protocols
+  # on cp-kafka 8.3.0 (Kafka 4.x). That mechanism is deprecated in favour of the share.version
+  # feature flag (Kafka 5.0), but is still functionally required to enable share groups in this
+  # version, so the broker logs this deprecation warning on every startup. Expected here.
+  "group.coordinator.rebalance.protocols. is deprecated"
   "Performing controller activation"
   "registered with feature metadata.version"
   "Replayed TopicRecord for"

data/docker-compose-ssl.yml

@@ -1,7 +1,7 @@
 services:
   kafka:
     container_name: kafka
-    image: confluentinc/cp-kafka:8.2.1
+    image: confluentinc/cp-kafka:8.3.0
     ports:
       - 9092:9092 # Support PLAINTEXT so we can run one docker setup for SSL and PLAINTEXT
       - 9093:9093
@@ -22,6 +22,9 @@ services:
       KAFKA_AUTO_CREATE_TOPICS_ENABLE: 'false'
       KAFKA_TRANSACTION_STATE_LOG_REPLICATION_FACTOR: 1
       KAFKA_TRANSACTION_STATE_LOG_MIN_ISR: 1
+      KAFKA_GROUP_COORDINATOR_REBALANCE_PROTOCOLS: 'classic,consumer,share'
+      KAFKA_SHARE_COORDINATOR_STATE_TOPIC_REPLICATION_FACTOR: 1
+      KAFKA_SHARE_COORDINATOR_STATE_TOPIC_MIN_ISR: 1
       KAFKA_ALLOW_EVERYONE_IF_NO_ACL_FOUND: "true"
       KAFKA_AUTHORIZER_CLASS_NAME: org.apache.kafka.metadata.authorizer.StandardAuthorizer
 

data/docker-compose.yml

@@ -1,7 +1,7 @@
 services:
   kafka:
     container_name: kafka
-    image: confluentinc/cp-kafka:8.2.1
+    image: confluentinc/cp-kafka:8.3.0
 
     ports:
       - 9092:9092
@@ -21,5 +21,8 @@ services:
       KAFKA_AUTO_CREATE_TOPICS_ENABLE: 'false'
       KAFKA_TRANSACTION_STATE_LOG_REPLICATION_FACTOR: 1
       KAFKA_TRANSACTION_STATE_LOG_MIN_ISR: 1
+      KAFKA_GROUP_COORDINATOR_REBALANCE_PROTOCOLS: 'classic,consumer,share'
+      KAFKA_SHARE_COORDINATOR_STATE_TOPIC_REPLICATION_FACTOR: 1
+      KAFKA_SHARE_COORDINATOR_STATE_TOPIC_MIN_ISR: 1
       KAFKA_ALLOW_EVERYONE_IF_NO_ACL_FOUND: "true"
       KAFKA_AUTHORIZER_CLASS_NAME: org.apache.kafka.metadata.authorizer.StandardAuthorizer

data/lib/rdkafka/abstract_handle.rb

@@ -14,9 +14,16 @@ module Rdkafka
 
     # Registry for registering all the handles.
     REGISTRY = {}
+    # Guards REGISTRY mutations. The registry is shared across producing/consuming threads and the
+    # background polling thread (which removes handles from FFI callbacks), so the Hash must not be
+    # mutated concurrently. This is effectively safe on MRI under the GVL but not on JRuby, where a
+    # lost write could leave a handle unregistered (never unlocked -> `wait` times out for a
+    # delivered message) or never removed (permanent leak).
+    REGISTRY_MUTEX = Mutex.new
     # Default wait timeout is 31 years
     MAX_WAIT_TIMEOUT_FOREVER = 10_000_000_000
 
+    private_constant :REGISTRY_MUTEX
     private_constant :MAX_WAIT_TIMEOUT_FOREVER
 
     class << self
@@ -25,17 +32,28 @@ module Rdkafka
       # @param handle [AbstractHandle] any handle we want to register
       def register(handle)
         address = handle.to_ptr.address
-        REGISTRY[address] = handle
+        REGISTRY_MUTEX.synchronize { REGISTRY[address] = handle }
       end
 
       # Removes handle from the register based on the handle address
       #
       # @param address [Integer] address of the registered handle we want to remove
       def remove(address)
-        REGISTRY.delete(address)
+        REGISTRY_MUTEX.synchronize { REGISTRY.delete(address) }
       end
     end
 
+    # Operation result prepared by the background event callback. Background events are
+    # destroyed as soon as the callback returns, so anything the waiting thread needs has to be
+    # copied out of event-owned memory into Ruby objects and stored here before `#unlock` runs.
+    # When result parsing fails, holds the captured exception so it can be re-raised on the
+    # waiting thread.
+    attr_accessor :result
+
+    # Broker-provided error message copied out of event-owned memory by the background event
+    # callback, used by `#raise_error`.
+    attr_accessor :broker_message
+
     def initialize
       @mutex = Thread::Mutex.new
       @resource = Thread::ConditionVariable.new
@@ -122,6 +140,17 @@ module Rdkafka
       raise "Must be implemented by subclass!"
     end
 
+    # Returns the operation result prepared by the background event callback, re-raising an
+    # exception that was captured while the event memory was still readable.
+    #
+    # @return [Object] operation-specific result
+    # @raise [RdkafkaError] when result parsing in the event callback failed
+    def prepared_result
+      raise(result) if result.is_a?(Exception)
+
+      result
+    end
+
     # Allow subclasses to override
     def raise_error
       raise RdkafkaError.new(self[:response])

data/lib/rdkafka/admin/config_binding_result.rb

@@ -17,12 +17,12 @@ module Rdkafka
         @synonyms = []
 
         # The code below builds up the config synonyms using same config binding
-        pointer_to_size_t = FFI::MemoryPointer.new(:int32)
+        pointer_to_size_t = FFI::MemoryPointer.new(:size_t)
         synonym_ptr = Bindings.rd_kafka_ConfigEntry_synonyms(config_ptr, pointer_to_size_t)
         synonyms_ptr = synonym_ptr.read_array_of_pointer(pointer_to_size_t.read_int)
 
         (1..pointer_to_size_t.read_int).map do |ar|
-          self.class.new synonyms_ptr[ar - 1]
+          @synonyms << self.class.new(synonyms_ptr[ar - 1])
         end
       end
     end

data/lib/rdkafka/admin/create_acl_handle.rb

@@ -5,17 +5,18 @@ module Rdkafka
     # Handle for create ACL operation
     class CreateAclHandle < AbstractHandle
       layout :pending, :bool,
-        :response, :int,
-        :response_string, :pointer
+        :response, :int
 
       # @return [String] the name of the operation
       def operation_name
         "create acl"
       end
 
-      # @return [CreateAclReport] instance with rdkafka_response value as 0 and rdkafka_response_string value as empty string if the acl creation was successful
+      # @return [CreateAclReport] report prepared by the background event callback, with
+      #   rdkafka_response value as 0 and rdkafka_response_string value as empty string if the
+      #   acl creation was successful
       def create_result
-        CreateAclReport.new(rdkafka_response: self[:response], rdkafka_response_string: self[:response_string])
+        prepared_result
       end
 
       # Raises an error if the operation failed
@@ -23,7 +24,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/create_acl_report.rb

@@ -4,7 +4,8 @@ module Rdkafka
   class Admin
     # Report for create ACL operation result
     class CreateAclReport
-      # Upon successful creation of Acl RD_KAFKA_RESP_ERR_NO_ERROR - 0 is returned as rdkafka_response
+      # Upon successful creation of Acl RD_KAFKA_RESP_ERR_NO_ERROR - 0 is returned as
+      # rdkafka_response
       # @return [Integer]
       attr_reader :rdkafka_response
 

data/lib/rdkafka/admin/create_partitions_handle.rb

@@ -3,18 +3,16 @@ module Rdkafka
     # Handle for create partitions operation
     class CreatePartitionsHandle < AbstractHandle
       layout :pending, :bool,
-        :response, :int,
-        :error_string, :pointer,
-        :result_name, :pointer
+        :response, :int
 
       # @return [String] the name of the operation
       def operation_name
         "create partitions"
       end
 
-      # @return [Boolean] whether the create topic was successful
+      # @return [CreatePartitionsReport] report prepared by the background event callback
       def create_result
-        CreatePartitionsReport.new(self[:error_string], self[:result_name])
+        prepared_result
       end
 
       # Raises an error if the operation failed
@@ -22,7 +20,7 @@ module Rdkafka
       def raise_error
         raise RdkafkaError.new(
           self[:response],
-          broker_message: CreateTopicReport.new(self[:error_string], self[:result_name]).error_string
+          broker_message: broker_message
         )
       end
     end

data/lib/rdkafka/admin/create_topic_handle.rb

@@ -5,18 +5,16 @@ module Rdkafka
     # Handle for create topic operation
     class CreateTopicHandle < AbstractHandle
       layout :pending, :bool,
-        :response, :int,
-        :error_string, :pointer,
-        :result_name, :pointer
+        :response, :int
 
       # @return [String] the name of the operation
       def operation_name
         "create topic"
       end
 
-      # @return [Boolean] whether the create topic was successful
+      # @return [CreateTopicReport] report prepared by the background event callback
       def create_result
-        CreateTopicReport.new(self[:error_string], self[:result_name])
+        prepared_result
       end
 
       # Raises an error if the operation failed
@@ -24,7 +22,7 @@ module Rdkafka
       def raise_error
         raise RdkafkaError.new(
           self[:response],
-          broker_message: CreateTopicReport.new(self[:error_string], self[:result_name]).error_string
+          broker_message: broker_message
         )
       end
     end

data/lib/rdkafka/admin/delete_acl_handle.rb

@@ -5,19 +5,17 @@ module Rdkafka
     # Handle for delete ACL operation
     class DeleteAclHandle < AbstractHandle
       layout :pending, :bool,
-        :response, :int,
-        :response_string, :pointer,
-        :matching_acls, :pointer,
-        :matching_acls_count, :int
+        :response, :int
 
       # @return [String] the name of the operation
       def operation_name
         "delete acl"
       end
 
-      # @return [DeleteAclReport] instance with an array of matching_acls
+      # @return [DeleteAclReport] report prepared by the background event callback, with an
+      #   array of matching_acls
       def create_result
-        DeleteAclReport.new(matching_acls: self[:matching_acls], matching_acls_count: self[:matching_acls_count])
+        prepared_result
       end
 
       # Raises an error if the operation failed
@@ -25,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/delete_groups_handle.rb

@@ -4,10 +4,8 @@ module Rdkafka
   class Admin
     # Handle for delete groups operation
     class DeleteGroupsHandle < AbstractHandle
-      layout :pending, :bool, # TODO: ???
-        :response, :int,
-        :error_string, :pointer,
-        :result_name, :pointer
+      layout :pending, :bool,
+        :response, :int
 
       # @return [String] the name of the operation
       def operation_name
@@ -17,7 +15,7 @@ module Rdkafka
       # Creates the result report
       # @return [DeleteGroupsReport]
       def create_result
-        DeleteGroupsReport.new(self[:error_string], self[:result_name])
+        prepared_result
       end
 
       # Raises an error if the operation failed
@@ -25,7 +23,7 @@ module Rdkafka
       def raise_error
         raise RdkafkaError.new(
           self[:response],
-          broker_message: create_result.error_string
+          broker_message: broker_message
         )
       end
     end

data/lib/rdkafka/admin/delete_records_handle.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+module Rdkafka
+  class Admin
+    # Handle for delete records operation
+    class DeleteRecordsHandle < AbstractHandle
+      layout :pending, :bool,
+        :response, :int
+
+      # @return [String] the name of the operation
+      def operation_name
+        "delete records"
+      end
+
+      # @return [DeleteRecordsReport] report prepared by the background event callback, with the
+      #   post-deletion low-watermark offsets (or per-partition errors)
+      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/delete_records_report.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+module Rdkafka
+  class Admin
+    # Report for delete records operation result
+    class DeleteRecordsReport
+      # Per-partition results. Each partition's `offset` is the post-deletion low-watermark (the
+      # smallest available offset of all live replicas) and its `err` carries the per-partition
+      # error code, if deletion failed for that partition.
+      # @return [Rdkafka::Consumer::TopicPartitionList]
+      attr_reader :offsets
+
+      # @param result_ptr [FFI::Pointer] pointer to the `rd_kafka_DeleteRecords_result_t`
+      def initialize(result_ptr)
+        @offsets = Rdkafka::Consumer::TopicPartitionList.new
+
+        return if result_ptr.null?
+
+        native_tpl = Bindings.rd_kafka_DeleteRecords_result_offsets(result_ptr)
+
+        @offsets = Rdkafka::Consumer::TopicPartitionList.from_native_tpl(native_tpl)
+      end
+    end
+  end
+end

data/lib/rdkafka/admin/delete_topic_handle.rb

@@ -5,18 +5,16 @@ module Rdkafka
     # Handle for delete topic operation
     class DeleteTopicHandle < AbstractHandle
       layout :pending, :bool,
-        :response, :int,
-        :error_string, :pointer,
-        :result_name, :pointer
+        :response, :int
 
       # @return [String] the name of the operation
       def operation_name
         "delete topic"
       end
 
-      # @return [Boolean] whether the delete topic was successful
+      # @return [DeleteTopicReport] report prepared by the background event callback
       def create_result
-        DeleteTopicReport.new(self[:error_string], self[:result_name])
+        prepared_result
       end
 
       # Raises an error if the operation failed
@@ -24,7 +22,7 @@ module Rdkafka
       def raise_error
         raise RdkafkaError.new(
           self[:response],
-          broker_message: DeleteTopicReport.new(self[:error_string], self[:result_name]).error_string
+          broker_message: broker_message
         )
       end
     end

data/lib/rdkafka/admin/describe_acl_handle.rb

@@ -5,19 +5,17 @@ module Rdkafka
     # Handle for describe ACL operation
     class DescribeAclHandle < AbstractHandle
       layout :pending, :bool,
-        :response, :int,
-        :response_string, :pointer,
-        :acls, :pointer,
-        :acls_count, :int
+        :response, :int
 
       # @return [String] the name of the operation.
       def operation_name
         "describe acl"
       end
 
-      # @return [DescribeAclReport] instance with an array of acls that matches the request filters.
+      # @return [DescribeAclReport] report prepared by the background event callback, with an
+      #   array of acls that matches the request filters.
       def create_result
-        DescribeAclReport.new(acls: self[:acls], acls_count: self[:acls_count])
+        prepared_result
       end
 
       # Raises an error if the operation failed
@@ -25,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/describe_acl_report.rb

@@ -4,7 +4,8 @@ module Rdkafka
   class Admin
     # Report for describe ACL operation result
     class DescribeAclReport
-      # acls that exists in the cluster for the resource_type, resource_name and pattern_type filters provided in the request.
+      # acls that exists in the cluster for the resource_type, resource_name and pattern_type
+      # filters provided in the request.
       # @return [Rdkafka::Bindings::AclBindingResult] array of matching acls.
       attr_reader :acls
 

data/lib/rdkafka/admin/describe_configs_handle.rb

@@ -5,22 +5,16 @@ module Rdkafka
     # Handle for describe configs operation
     class DescribeConfigsHandle < AbstractHandle
       layout :pending, :bool,
-        :response, :int,
-        :response_string, :pointer,
-        :config_entries, :pointer,
-        :entry_count, :int
+        :response, :int
 
       # @return [String] the name of the operation.
       def operation_name
         "describe configs"
       end
 
-      # @return [DescribeAclReport] instance with an array of acls that matches the request filters.
+      # @return [DescribeConfigsReport] report prepared by the background event callback
       def create_result
-        DescribeConfigsReport.new(
-          config_entries: self[:config_entries],
-          entry_count: self[:entry_count]
-        )
+        prepared_result
       end
 
       # Raises an error if the operation failed
@@ -28,7 +22,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/describe_configs_report.rb

@@ -19,7 +19,7 @@ module Rdkafka
           .each do |config_resource_result_ptr|
             config_resource_result = ConfigResourceBindingResult.new(config_resource_result_ptr)
 
-            pointer_to_size_t = FFI::MemoryPointer.new(:int32)
+            pointer_to_size_t = FFI::MemoryPointer.new(:size_t)
             configs_ptr = Bindings.rd_kafka_ConfigResource_configs(
               config_resource_result_ptr,
               pointer_to_size_t
@@ -32,10 +32,6 @@ module Rdkafka
 
             @resources << config_resource_result
           end
-      ensure
-        return if config_entries == FFI::Pointer::NULL
-
-        Bindings.rd_kafka_ConfigResource_destroy_array(config_entries, entry_count)
       end
 
       private

data/lib/rdkafka/admin/incremental_alter_configs_handle.rb

@@ -5,22 +5,16 @@ module Rdkafka
     # Handle for incremental alter configs operation
     class IncrementalAlterConfigsHandle < AbstractHandle
       layout :pending, :bool,
-        :response, :int,
-        :response_string, :pointer,
-        :config_entries, :pointer,
-        :entry_count, :int
+        :response, :int
 
       # @return [String] the name of the operation.
       def operation_name
         "incremental alter configs"
       end
 
-      # @return [DescribeAclReport] instance with an array of acls that matches the request filters.
+      # @return [IncrementalAlterConfigsReport] report prepared by the background event callback
       def create_result
-        IncrementalAlterConfigsReport.new(
-          config_entries: self[:config_entries],
-          entry_count: self[:entry_count]
-        )
+        prepared_result
       end
 
       # Raises an error if the operation failed
@@ -28,7 +22,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/incremental_alter_configs_report.rb

@@ -19,7 +19,7 @@ module Rdkafka
           .each do |config_resource_result_ptr|
             config_resource_result = ConfigResourceBindingResult.new(config_resource_result_ptr)
 
-            pointer_to_size_t = FFI::MemoryPointer.new(:int32)
+            pointer_to_size_t = FFI::MemoryPointer.new(:size_t)
             configs_ptr = Bindings.rd_kafka_ConfigResource_configs(
               config_resource_result_ptr,
               pointer_to_size_t
@@ -32,10 +32,6 @@ module Rdkafka
 
             @resources << config_resource_result
           end
-      ensure
-        return if config_entries == FFI::Pointer::NULL
-
-        Bindings.rd_kafka_ConfigResource_destroy_array(config_entries, entry_count)
       end
 
       private