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

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: bf144e733ead8d092df02370f368a972ddce305dacd7ffe7b1eeb23376778308
-  data.tar.gz: f78f039beab386856654c65b8d7e9b8c57d2a04e62610e3a6e0c881a6aee52dd
+  metadata.gz: cb6dd6580bf5c14ddceaa2ccd38deaad34cf4e6e81e994c82df73e62fb831f77
+  data.tar.gz: c26f74ea68b3c14ace182f7f8b2da1184cceb59d6063b044a7efb3a84a022eef
 SHA512:
-  metadata.gz: d21d838a647a08fb3593b7f270341441239dc0ef2d62a72df076e28ff24bc0b3e808100a13e1d6aa7d011b210e0423a7bf5b4595ed2ffbb872139dc280cd828f
-  data.tar.gz: f8b83914f79932a3d910206542cfb5ace7aabf0cf20533ca0e701b97f40de527fbfa8e799094373970e6d3ad57021f41ba7b0212c30c67e9c2039c9c39240664
+  metadata.gz: 6b954711968c6acaa5beffa2995a33262bef8e2297b18eb3d9e828dd0be43818bfa5be73a7a20bfe13a8d19ee08ec4436e38e7b63a69948f3b85b7d06843d5db
+  data.tar.gz: f2003f4f608143b78dd9caab59a30d2fd96b5ed1a280ea9d1388cb4d5ff386d26655f2b0b3e15ec16b450b7df23118cfae1f1f99f229139e19243cd6bb7f3d5c

data/CHANGELOG.md

@@ -1,10 +1,50 @@
 # Rdkafka Changelog
 
+## v0.28.1 (2026-09-04)
+- [Enhancement] Add `Admin#delete_records`, wrapping librdkafka's `DeleteRecords` admin API. Deletes all messages in a partition up to (but not including) a given offset - accepts an integer offset or `:end` to clear all current data. Ported from rdkafka-ruby (#956).
+- [Enhancement] Add `Admin#list_consumer_groups`, wrapping librdkafka's `ListConsumerGroups` admin API. Returns a cluster-wide listing of consumer groups (`group_id`, `is_simple_consumer_group`, state) plus any per-broker errors. Ported from rdkafka-ruby (#955).
+- [Fix] Make `NativeKafka#close` fork-aware so a forked child no longer segfaults on exit. Handles record their creator pid and skip the native teardown in any other process.
+- [Fix] Stabilize the flaky partitions count cache statistics spec.
+- [Fix] Stabilize the `to_native_tpl` leak integration spec against RSS measurement noise.
+
+## v0.28.0 (2026-07-12)
+- [Enhancement] Bump librdkafka to `2.14.2`. Maintenance release: fixes duplicate groups in `ListConsumerGroups` when multiple brokers return the same group, a data race in timers, and bumps bundled OpenSSL/libcurl/zstd/zlib/cJSON dependencies (several CVEs).
+- [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] Name the failing partition and topic in the `RdkafkaError` raised for per-partition `list_offsets` errors (previously a bare error code), preserving the per-partition context the pre-batching `Consumer#lag` watermark errors carried.
+- [Enhancement] Add `Consumer#list_offsets`, mirroring `Admin#list_offsets`, so offsets can be queried on an existing consumer handle without a dedicated admin connection, and rebuild `Consumer#lag` on top of it as one batched query instead of a roundtrip per partition.
+- [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] 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] 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] Stop `poll_batch`/`poll_batch_nb` from discarding a whole batch when one message fails to build. The failure is now surfaced inline as an `RdkafkaError` in the returned array, preserving the rest of the batch.
+- [Fix] Add the missing `closed_consumer_check` to `Consumer#position`, so it raises a consistent `ClosedConsumerError` like every sibling offset method.
+- [Fix] Stop leaking the native `rd_kafka_topic_conf_t` in `Producer#set_topic_config` when a per-topic config value is rejected.
+- [Fix] Raise instead of silently dropping a rejected `incremental_alter_configs` entry, which previously left the alter request reporting success.
+- [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] 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] 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, which previously leaked the half-built list.
+- [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] 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.
+- [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] 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] 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] 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 `Producer#produce` from orphaning the delivery handle in the process-global registry when it fails after registering it.
+- [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] Stabilize the flaky `Consumer#lag` spec on overloaded CI. Backported from rdkafka-ruby (#912).
+- [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] Forward `broker_message` and `instance_name` through `RdkafkaError.build`; both were previously discarded on the `rd_kafka_error_t` pointer path.
+- [Fix] Synchronize `AbstractHandle::REGISTRY` mutations with a mutex, which could otherwise lose a write on JRuby and leave a handle unregistered or leaked.
+- [Fix] Stop the `Metadata` retry loop from clobbering the request timeout and blocking for minutes. The request timeout is left unchanged across retries, the backoff is capped, and the loop is bounded by a ~5s wall-clock budget after a floor of 3 attempts.
+- [Fix] Cache the partition count for a missing topic, so `produce` with a `partition_key` to a not-yet-created topic no longer runs a blocking metadata query on every message.
+
 ## 0.27.2 (2026-05-21)
 - [Enhancement] `poll_batch` and `poll_batch_nb` now return error events inline as `RdkafkaError` objects rather than raising on the first error. The return type is `Array<Message, RdkafkaError>` and callers are responsible for handling errors in the result.
 
 ## 0.27.1 (2026-05-14)
-- [Fix] `poll_nb`, `poll_nb_each`, `poll_batch`, and `poll_batch_nb` now raise `RdkafkaError` with `details` populated (`{topic:, partition:, offset:}`) when a message contains an error (e.g. `:partition_eof`). Previously these methods raised via `RdkafkaError.new(code)`, discarding the native message struct context. They now use `RdkafkaError.validate!(native_message, client_ptr: inner)`, consistent with `poll`.
+- [Fix] `poll_nb`, `poll_nb_each`, `poll_batch` and `poll_batch_nb` now raise `RdkafkaError` with `details` populated (`{topic:, partition:, offset:}`) when a message contains an error, consistent with `poll`.
 
 ## 0.27.0 (2026-05-08)
 - [Feature] Add `Consumer#poll_batch(timeout_ms, max_items:)` and `Consumer#poll_batch_nb(timeout_ms, max_items:)` for batch message polling via `rd_kafka_consume_batch_queue` (from upstream).

data/README.md

@@ -1,6 +1,6 @@
 # Karafka-Rdkafka
 
-[![Build Status](https://github.com/karafka/karafka-rdkafka/actions/workflows/ci_linux_ubuntu_x86_64_gnu.yml/badge.svg)](https://github.com/karafka/karafka-rdkafka/actions/workflows/ci_linux_x86_64_gnu.yml)
+[![Build Status](https://github.com/karafka/karafka-rdkafka/actions/workflows/ci_linux_ubuntu_x86_64_gnu.yml/badge.svg)](https://github.com/karafka/karafka-rdkafka/actions/workflows/ci_linux_ubuntu_x86_64_gnu.yml)
 [![Gem Version](https://badge.fury.io/rb/karafka-rdkafka.svg)](https://badge.fury.io/rb/karafka-rdkafka)
 [![Join the chat at https://slack.karafka.io](https://raw.githubusercontent.com/karafka/misc/master/slack.svg)](https://slack.karafka.io)
 
@@ -61,13 +61,14 @@ Contributions should generally be made to the upstream [rdkafka-ruby repository]
 
 ## Versions
 
-| rdkafka-ruby | librdkafka | patches |
+| karafka-rdkafka | librdkafka | patches |
 |-|-|-|
+| 0.28.x (2026-07-12) | 2.14.2 (2026-06-03)  | yes |
 | 0.27.x (2026-05-08) | 2.14.1 (2026-04-15)  | yes |
 | 0.26.x (2026-04-11) | 2.14.0 (2026-04-01)  | yes |
 | 0.25.x (2026-04-02) | 2.13.2 (2026-03-02)  | yes |
 | 0.24.x (2026-02-25) | 2.13.0 (2026-01-05)  | yes |
-| 0.23.x (2025-11-01) | 2.12.1 (2025-10-16)  | yes |
+| 0.23.x (2025-11-01) | 2.12.1 (2025-10-21)  | yes |
 | 0.22.x (2025-09-26) | 2.11.1 (2025-08-18)  | yes |
 | 0.21.x (2025-08-18) | 2.11.0 (2025-07-03)  | yes |
 | 0.20.x (2025-07-17) | 2.8.0  (2025-01-07)  | yes |

data/docker-compose-ssl.yml

@@ -1,7 +1,7 @@
 services:
   kafka:
     container_name: kafka
-    image: confluentinc/cp-kafka:8.2.0
+    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

data/docker-compose.yml

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

data/karafka-rdkafka.gemspec

@@ -19,6 +19,7 @@ Gem::Specification.new do |gem|
     next true if file.start_with?(".")
     next true if file.start_with?("spec/")
     next true if file.start_with?("ext/README.md")
+    next true if file.start_with?("Gemfile")
 
     false
   end

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
@@ -118,13 +136,28 @@ module Rdkafka
     end
 
     # @return [Object] operation-specific result
+    #
+    # Defaults to the result prepared by the background event callback (see
+    # {#prepared_result}). Subclasses backed by a synchronous callback that writes the result
+    # into struct fields (e.g. {Producer::DeliveryHandle}) override this.
     def create_result
-      raise "Must be implemented by subclass!"
+      prepared_result
+    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
-      RdkafkaError.validate!(self[:response])
+      RdkafkaError.validate!(self[:response], broker_message: broker_message)
     end
 
     # Error that is raised when waiting for the handle to complete

data/lib/rdkafka/admin/config_binding_result.rb

@@ -17,7 +17,7 @@ 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)
 

data/lib/rdkafka/admin/create_acl_handle.rb

@@ -5,25 +5,19 @@ 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
-      def create_result
-        CreateAclReport.new(rdkafka_response: self[:response], rdkafka_response_string: self[:response_string])
-      end
-
       # Raises an error if the operation failed
       # @raise [RdkafkaError]
       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,31 +3,12 @@ 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
-      def create_result
-        CreatePartitionsReport.new(self[:error_string], self[:result_name])
-      end
-
-      # Raises an error if the operation failed
-      # @raise [RdkafkaError]
-      def raise_error
-        RdkafkaError.validate!(
-          self[:response],
-          broker_message: CreatePartitionsReport.new(
-            self[:error_string],
-            self[:result_name]
-          ).error_string
-        )
-      end
     end
   end
 end

data/lib/rdkafka/admin/create_topic_handle.rb

@@ -5,31 +5,12 @@ 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
-      def create_result
-        CreateTopicReport.new(self[:error_string], self[:result_name])
-      end
-
-      # Raises an error if the operation failed
-      # @raise [RdkafkaError]
-      def raise_error
-        RdkafkaError.validate!(
-          self[:response],
-          broker_message: CreateTopicReport.new(
-            self[:error_string],
-            self[:result_name]
-          ).error_string
-        )
-      end
     end
   end
 end

data/lib/rdkafka/admin/delete_acl_handle.rb

@@ -5,27 +5,19 @@ 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
-      def create_result
-        DeleteAclReport.new(matching_acls: self[:matching_acls], matching_acls_count: self[:matching_acls_count])
-      end
-
       # Raises an error if the operation failed
       # @raise [RdkafkaError]
       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,28 +4,20 @@ 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
         "delete groups"
       end
 
-      # Creates the result report
-      # @return [DeleteGroupsReport]
-      def create_result
-        DeleteGroupsReport.new(self[:error_string], self[:result_name])
-      end
-
       # Raises an error if the operation failed
       # @raise [RdkafkaError]
       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,31 +5,12 @@ 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
-      def create_result
-        DeleteTopicReport.new(self[:error_string], self[:result_name])
-      end
-
-      # Raises an error if the operation failed
-      # @raise [RdkafkaError]
-      def raise_error
-        RdkafkaError.validate!(
-          self[:response],
-          broker_message: DeleteTopicReport.new(
-            self[:error_string],
-            self[:result_name]
-          ).error_string
-        )
-      end
     end
   end
 end

data/lib/rdkafka/admin/describe_acl_handle.rb

@@ -5,27 +5,19 @@ 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.
-      def create_result
-        DescribeAclReport.new(acls: self[:acls], acls_count: self[:acls_count])
-      end
-
       # Raises an error if the operation failed
       # @raise [RdkafkaError]
       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,30 +5,19 @@ 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.
-      def create_result
-        DescribeConfigsReport.new(
-          config_entries: self[:config_entries],
-          entry_count: self[:entry_count]
-        )
-      end
-
       # Raises an error if the operation failed
       # @raise [RdkafkaError]
       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

@@ -6,7 +6,10 @@ module Rdkafka
     class DescribeConfigsReport
       attr_reader :resources
 
-      # @param config_entries [FFI::Pointer] pointer to config entries array
+      # @param config_entries [FFI::Pointer] pointer to the event-owned config entries array.
+      #   It is only read here - the array is destroyed together with the result event by the
+      #   background event callback, so this report must be built while the event is alive and
+      #   must copy everything it needs into Ruby objects.
       # @param entry_count [Integer] number of config entries
       def initialize(config_entries:, entry_count:)
         @resources = []
@@ -19,7 +22,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 +35,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,30 +5,19 @@ 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.
-      def create_result
-        IncrementalAlterConfigsReport.new(
-          config_entries: self[:config_entries],
-          entry_count: self[:entry_count]
-        )
-      end
-
       # Raises an error if the operation failed
       # @raise [RdkafkaError]
       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

@@ -6,7 +6,10 @@ module Rdkafka
     class IncrementalAlterConfigsReport
       attr_reader :resources
 
-      # @param config_entries [FFI::Pointer] pointer to config entries array
+      # @param config_entries [FFI::Pointer] pointer to the event-owned config entries array.
+      #   It is only read here - the array is destroyed together with the result event by the
+      #   background event callback, so this report must be built while the event is alive and
+      #   must copy everything it needs into Ruby objects.
       # @param entry_count [Integer] number of config entries
       def initialize(config_entries:, entry_count:)
         @resources = []
@@ -19,7 +22,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 +35,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