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

data/lib/rdkafka/bindings.rb

@@ -58,6 +58,7 @@ module Rdkafka
       end
     end
 
+    RD_KAFKA_RESP_ERR__TIMED_OUT = -185
     RD_KAFKA_RESP_ERR__ASSIGN_PARTITIONS = -175
     RD_KAFKA_RESP_ERR__REVOKE_PARTITIONS = -174
     RD_KAFKA_RESP_ERR__STATE = -172
@@ -87,7 +88,7 @@ module Rdkafka
 
     # This function comes from our patch on top of librdkafka. It allows os to load all the
     # librdkafka components without initializing the client
-    # @see https://github.com/confluentinc/librdkafka/issues/4590
+    # See: https://github.com/confluentinc/librdkafka/issues/4590
     attach_function :rd_kafka_global_init, [], :void
 
     # Polling
@@ -105,8 +106,12 @@ module Rdkafka
     # Metadata
 
     attach_function :rd_kafka_name, [:pointer], :string
-    attach_function :rd_kafka_memberid, [:pointer], :string, blocking: true
-    attach_function :rd_kafka_clusterid, [:pointer], :string, blocking: true
+    # Both return a newly allocated string the caller must release with rd_kafka_mem_free; they
+    # are attached as :pointer (not :string) so we can free them instead of leaking. clusterid
+    # also takes a timeout_ms (the previous arity was wrong, leaving that argument as garbage).
+    attach_function :rd_kafka_memberid, [:pointer], :pointer, blocking: true
+    attach_function :rd_kafka_clusterid, [:pointer, :int], :pointer, blocking: true
+    attach_function :rd_kafka_mem_free, [:pointer, :pointer], :void
     attach_function :rd_kafka_metadata, [:pointer, :int, :pointer, :pointer, :int], :int, blocking: true
     attach_function :rd_kafka_metadata_destroy, [:pointer], :void, blocking: true
 
@@ -242,6 +247,8 @@ module Rdkafka
 
     attach_function :rd_kafka_conf_new, [], :pointer
     attach_function :rd_kafka_conf_set, [:pointer, :string, :string, :pointer, :int], :kafka_config_response
+    attach_function :rd_kafka_conf_get, [:pointer, :string, :pointer, :pointer], :kafka_config_response
+    attach_function :rd_kafka_conf, [:pointer], :pointer
     attach_function :rd_kafka_conf_dump, [:pointer, :pointer], :pointer
     attach_function :rd_kafka_conf_dump_free, [:pointer, :size_t], :void
     attach_function :rd_kafka_conf_destroy, [:pointer], :void
@@ -264,13 +271,15 @@ module Rdkafka
 
     # Queue IO Event Support - for fiber scheduler integration
     # Enables notifications to a custom FD when queue transitions from empty to non-empty
-    # @param queue rd_kafka_queue_t* - the queue to monitor
-    # @param fd int - file descriptor to write to (provide your own pipe/eventfd)
-    # @param payload const void* - data to write to fd
-    # @param size size_t - size of payload
+    # Arguments:
+    # - queue (rd_kafka_queue_t*) - the queue to monitor
+    # - fd (int) - file descriptor to write to (provide your own pipe/eventfd)
+    # - payload (const void*) - data to write to fd
+    # - size (size_t) - size of payload
     attach_function :rd_kafka_queue_io_event_enable, [:pointer, :int, :pointer, :size_t], :void
     # Per topic configs
     attach_function :rd_kafka_topic_conf_new, [], :pointer
+    attach_function :rd_kafka_topic_conf_destroy, [:pointer], :void
     attach_function :rd_kafka_topic_conf_set, [:pointer, :string, :string, :pointer, :int], :kafka_config_response
 
     LogCallback = FFI::Function.new(
@@ -335,7 +344,8 @@ module Rdkafka
     # across different parts of the codebase (callbacks, testing utilities, etc.).
     #
     # @param client_ptr [FFI::Pointer] Native kafka client pointer
-    # @return [Hash, nil] Hash with :error_code and :error_string if fatal error occurred, nil otherwise
+    # @return [Hash, nil] Hash with :error_code and :error_string if fatal error occurred,
+    #   nil otherwise
     #
     # @example
     #   details = Rdkafka::Bindings.extract_fatal_error(client_ptr)
@@ -380,9 +390,10 @@ module Rdkafka
       end
     end
 
-    # The OAuth callback is currently global and contextless.
-    # This means that the callback will be called for all instances, and the callback must be able to determine to which instance it is associated.
-    # The instance name will be provided in the callback, allowing the callback to reference the correct instance.
+    # The OAuth callback is currently global and contextless. This means that the callback will be
+    # called for all instances, and the callback must be able to determine to which instance it is
+    # associated. The instance name will be provided in the callback, allowing the callback to
+    # reference the correct instance.
     #
     # An example of how to use the instance name in the callback is given below.
     # The `refresh_token` is configured as the `oauthbearer_token_refresh_callback`.
@@ -493,7 +504,7 @@ module Rdkafka
 
     # Stats
 
-    attach_function :rd_kafka_query_watermark_offsets, [:pointer, :string, :int, :pointer, :pointer, :int], :int
+    attach_function :rd_kafka_query_watermark_offsets, [:pointer, :string, :int, :pointer, :pointer, :int], :int, blocking: true
 
     # Producer
     RD_KAFKA_VTYPE_END = 0
@@ -591,6 +602,37 @@ module Rdkafka
     attach_function :rd_kafka_event_DeleteGroups_result, [:pointer], :pointer, blocking: true # rd_kafka_event_t* => rd_kafka_DeleteGroups_result_t*
     attach_function :rd_kafka_DeleteGroups_result_groups, [:pointer, :pointer], :pointer, blocking: true # rd_kafka_DeleteGroups_result_t*, size_t* => rd_kafka_group_result_t**
 
+    # Delete Records
+    RD_KAFKA_ADMIN_OP_DELETERECORDS = 6   # rd_kafka_admin_op_t
+    RD_KAFKA_EVENT_DELETERECORDS_RESULT = 105 # rd_kafka_event_type_t
+
+    attach_function :rd_kafka_DeleteRecords, [:pointer, :pointer, :size_t, :pointer, :pointer], :void, blocking: true
+    attach_function :rd_kafka_DeleteRecords_new, [:pointer], :pointer, blocking: true
+    attach_function :rd_kafka_DeleteRecords_destroy, [:pointer], :void, blocking: true
+    attach_function :rd_kafka_event_DeleteRecords_result, [:pointer], :pointer, blocking: true # rd_kafka_event_t* => rd_kafka_DeleteRecords_result_t*
+    attach_function :rd_kafka_DeleteRecords_result_offsets, [:pointer], :pointer, blocking: true # rd_kafka_DeleteRecords_result_t* => rd_kafka_topic_partition_list_t*
+
+    # List Consumer Groups
+    RD_KAFKA_ADMIN_OP_LISTCONSUMERGROUPS = 12   # rd_kafka_admin_op_t
+    RD_KAFKA_EVENT_LISTCONSUMERGROUPS_RESULT = 0x2000 # rd_kafka_event_type_t
+
+    # Consumer group states (rd_kafka_consumer_group_state_t)
+    RD_KAFKA_CONSUMER_GROUP_STATE_UNKNOWN = 0
+    RD_KAFKA_CONSUMER_GROUP_STATE_PREPARING_REBALANCE = 1
+    RD_KAFKA_CONSUMER_GROUP_STATE_COMPLETING_REBALANCE = 2
+    RD_KAFKA_CONSUMER_GROUP_STATE_STABLE = 3
+    RD_KAFKA_CONSUMER_GROUP_STATE_DEAD = 4
+    RD_KAFKA_CONSUMER_GROUP_STATE_EMPTY = 5
+
+    attach_function :rd_kafka_ListConsumerGroups, [:pointer, :pointer, :pointer], :void, blocking: true
+    attach_function :rd_kafka_event_ListConsumerGroups_result, [:pointer], :pointer, blocking: true # rd_kafka_event_t* => rd_kafka_ListConsumerGroups_result_t*
+    attach_function :rd_kafka_ListConsumerGroups_result_valid, [:pointer, :pointer], :pointer, blocking: true # result*, size_t* => rd_kafka_ConsumerGroupListing_t**
+    attach_function :rd_kafka_ListConsumerGroups_result_errors, [:pointer, :pointer], :pointer, blocking: true # result*, size_t* => rd_kafka_error_t**
+    attach_function :rd_kafka_ConsumerGroupListing_group_id, [:pointer], :pointer, blocking: true # => const char*
+    attach_function :rd_kafka_ConsumerGroupListing_is_simple_consumer_group, [:pointer], :int, blocking: true
+    attach_function :rd_kafka_ConsumerGroupListing_state, [:pointer], :int, blocking: true
+    attach_function :rd_kafka_consumer_group_state_name, [:int], :pointer, blocking: true # => const char*
+
     # Background Queue and Callback
 
     attach_function :rd_kafka_conf_set_background_event_cb, [:pointer, :pointer], :void
@@ -606,6 +648,7 @@ module Rdkafka
 
     attach_function :rd_kafka_event_type, [:pointer], :int32
     attach_function :rd_kafka_event_opaque, [:pointer], :pointer
+    attach_function :rd_kafka_event_destroy, [:pointer], :void
 
     # Extracting data from topic results
 
@@ -652,21 +695,24 @@ module Rdkafka
     attach_function :rd_kafka_AclBindingFilter_new, [:int32, :pointer, :int32, :pointer, :pointer, :int32, :int32, :pointer, :size_t], :pointer
     attach_function :rd_kafka_AclBinding_destroy, [:pointer], :void
 
-    # rd_kafka_ResourceType_t - https://github.com/confluentinc/librdkafka/blob/292d2a66b9921b783f08147807992e603c7af059/src/rdkafka.h#L7307
+    # rd_kafka_ResourceType_t -
+    # https://github.com/confluentinc/librdkafka/blob/292d2a66b992/src/rdkafka.h#L7307
     RD_KAFKA_RESOURCE_ANY = 1
     RD_KAFKA_RESOURCE_TOPIC = 2
     RD_KAFKA_RESOURCE_GROUP = 3
     RD_KAFKA_RESOURCE_BROKER = 4
     RD_KAFKA_RESOURCE_TRANSACTIONAL_ID = 5
 
-    # rd_kafka_ResourcePatternType_t - https://github.com/confluentinc/librdkafka/blob/292d2a66b9921b783f08147807992e603c7af059/src/rdkafka.h#L7320
+    # rd_kafka_ResourcePatternType_t -
+    # https://github.com/confluentinc/librdkafka/blob/292d2a66b992/src/rdkafka.h#L7320
     RD_KAFKA_RESOURCE_PATTERN_UNKNOWN = 0
     RD_KAFKA_RESOURCE_PATTERN_ANY = 1
     RD_KAFKA_RESOURCE_PATTERN_MATCH = 2
     RD_KAFKA_RESOURCE_PATTERN_LITERAL = 3
     RD_KAFKA_RESOURCE_PATTERN_PREFIXED = 4
 
-    # rd_kafka_AclOperation_t - https://github.com/confluentinc/librdkafka/blob/292d2a66b9921b783f08147807992e603c7af059/src/rdkafka.h#L8403
+    # rd_kafka_AclOperation_t -
+    # https://github.com/confluentinc/librdkafka/blob/292d2a66b992/src/rdkafka.h#L8403
     RD_KAFKA_ACL_OPERATION_ANY = 1
     RD_KAFKA_ACL_OPERATION_ALL = 2
     RD_KAFKA_ACL_OPERATION_READ = 3
@@ -680,7 +726,8 @@ module Rdkafka
     RD_KAFKA_ACL_OPERATION_ALTER_CONFIGS = 11
     RD_KAFKA_ACL_OPERATION_IDEMPOTENT_WRITE = 12
 
-    # rd_kafka_AclPermissionType_t - https://github.com/confluentinc/librdkafka/blob/292d2a66b9921b783f08147807992e603c7af059/src/rdkafka.h#L8435
+    # rd_kafka_AclPermissionType_t -
+    # https://github.com/confluentinc/librdkafka/blob/292d2a66b992/src/rdkafka.h#L8435
     RD_KAFKA_ACL_PERMISSION_TYPE_ANY = 1
     RD_KAFKA_ACL_PERMISSION_TYPE_DENY = 2
     RD_KAFKA_ACL_PERMISSION_TYPE_ALLOW = 3

data/lib/rdkafka/callbacks/base_handler.rb

@@ -0,0 +1,62 @@
+# frozen_string_literal: true
+
+module Rdkafka
+  module Callbacks
+    # Base class for admin background-event result handlers.
+    #
+    # Each subclass handles one librdkafka admin result event type: it extracts the result from
+    # the event, looks up the matching {AbstractHandle} in the registry and resolves it (sets the
+    # response, builds the report, copies the broker message, then unlocks it).
+    #
+    # The event is owned by the application and destroyed by {BackgroundEventCallback} right after
+    # dispatch, so handlers must copy everything they need out of event-owned memory into Ruby
+    # objects before returning.
+    #
+    # @private
+    class BaseHandler
+      class << self
+        # Processes a background event for the operation this handler is responsible for.
+        # @param event_ptr [FFI::Pointer] pointer to the event
+        # @return [void]
+        def call(event_ptr)
+          raise NotImplementedError, "#{name} must implement .call"
+        end
+
+        private
+
+        # Copies an event-owned C string into a Ruby string
+        # @param ptr [FFI::Pointer] pointer to the C string
+        # @return [String, nil] copied string or nil when NULL
+        def read_event_string(ptr)
+          ptr.null? ? nil : ptr.read_string
+        end
+
+        # Resolves a handle directly from an operation-level event error and unlocks it.
+        #
+        # librdkafka signals a failure of the whole admin operation (e.g. `_TIMED_OUT` when the
+        # brokers are unreachable, or `_DESTROY` when the client is closed with the request in
+        # flight) by setting the event error and delivering an *empty* results array. The
+        # per-element result handlers must not index into that empty array; they call this first
+        # and skip results parsing when it returns true. Without this, indexing `results[0]`
+        # raises inside the FFI callback, the handle is never unlocked, and the caller's `wait`
+        # blocks until its own timeout and raises `WaitTimeoutError`, losing the real error code.
+        #
+        # @param event_ptr [FFI::Pointer] pointer to the event
+        # @param handle [Rdkafka::AbstractHandle] the handle to resolve
+        # @return [Boolean] true when the event carried an operation-level error and the handle
+        #   was resolved here
+        def resolve_operation_error(event_ptr, handle)
+          error_code = Rdkafka::Bindings.rd_kafka_event_error(event_ptr)
+
+          return false if error_code == Rdkafka::Bindings::RD_KAFKA_RESP_ERR_NO_ERROR
+
+          handle[:response] = error_code
+          handle.broker_message = read_event_string(Rdkafka::Bindings.rd_kafka_event_error_string(event_ptr))
+          handle.unlock
+
+          true
+        end
+      end
+    end
+  end
+end

data/lib/rdkafka/callbacks/create_acl_handler.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+module Rdkafka
+  module Callbacks
+    # Handles `RD_KAFKA_EVENT_CREATEACLS_RESULT` events
+    # @private
+    class CreateAclHandler < BaseHandler
+      class << self
+        # Resolves the create-ACL handle from its result event
+        # @param event_ptr [FFI::Pointer] pointer to the event
+        # @return [void]
+        def call(event_ptr)
+          create_acls_result = Rdkafka::Bindings.rd_kafka_event_CreateAcls_result(event_ptr)
+
+          # Get the number of acl results
+          pointer_to_size_t = FFI::MemoryPointer.new(:size_t)
+          create_acl_result_array = Rdkafka::Bindings.rd_kafka_CreateAcls_result_acls(create_acls_result, pointer_to_size_t)
+          create_acl_results = CreateAclResult.create_acl_results_from_array(pointer_to_size_t.read_int, create_acl_result_array)
+          create_acl_handle_ptr = Rdkafka::Bindings.rd_kafka_event_opaque(event_ptr)
+
+          if create_acl_handle = Rdkafka::Admin::CreateAclHandle.remove(create_acl_handle_ptr.address)
+            unless resolve_operation_error(event_ptr, create_acl_handle)
+              create_acl_handle[:response] = create_acl_results[0].result_error
+              create_acl_handle.result = Rdkafka::Admin::CreateAclReport.new(
+                rdkafka_response: create_acl_results[0].result_error,
+                rdkafka_response_string: create_acl_results[0].error_string
+              )
+              create_acl_handle.broker_message = create_acl_handle.result.rdkafka_response_string
+
+              create_acl_handle.unlock
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/rdkafka/callbacks/create_partitions_handler.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+module Rdkafka
+  module Callbacks
+    # Handles `RD_KAFKA_ADMIN_OP_CREATEPARTITIONS_RESULT` events
+    # @private
+    class CreatePartitionsHandler < BaseHandler
+      class << self
+        # Resolves the create-partitions handle from its result event
+        # @param event_ptr [FFI::Pointer] pointer to the event
+        # @return [void]
+        def call(event_ptr)
+          create_partitionss_result = Rdkafka::Bindings.rd_kafka_event_CreatePartitions_result(event_ptr)
+
+          # Get the number of create topic results
+          pointer_to_size_t = FFI::MemoryPointer.new(:size_t)
+          create_partitions_result_array = Rdkafka::Bindings.rd_kafka_CreatePartitions_result_topics(create_partitionss_result, pointer_to_size_t)
+          create_partitions_results = TopicResult.create_topic_results_from_array(pointer_to_size_t.read_int, create_partitions_result_array)
+          create_partitions_handle_ptr = Rdkafka::Bindings.rd_kafka_event_opaque(event_ptr)
+
+          if create_partitions_handle = Rdkafka::Admin::CreatePartitionsHandle.remove(create_partitions_handle_ptr.address)
+            unless resolve_operation_error(event_ptr, create_partitions_handle)
+              create_partitions_handle[:response] = create_partitions_results[0].result_error
+              create_partitions_handle.result = Rdkafka::Admin::CreatePartitionsReport.new(
+                create_partitions_results[0].error_string,
+                create_partitions_results[0].result_name
+              )
+              create_partitions_handle.broker_message = create_partitions_handle.result.error_string
+
+              create_partitions_handle.unlock
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/rdkafka/callbacks/create_topic_handler.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+module Rdkafka
+  module Callbacks
+    # Handles `RD_KAFKA_EVENT_CREATETOPICS_RESULT` events
+    # @private
+    class CreateTopicHandler < BaseHandler
+      class << self
+        # Resolves the create-topic handle from its result event
+        # @param event_ptr [FFI::Pointer] pointer to the event
+        # @return [void]
+        def call(event_ptr)
+          create_topics_result = Rdkafka::Bindings.rd_kafka_event_CreateTopics_result(event_ptr)
+
+          # Get the number of create topic results
+          pointer_to_size_t = FFI::MemoryPointer.new(:size_t)
+          create_topic_result_array = Rdkafka::Bindings.rd_kafka_CreateTopics_result_topics(create_topics_result, pointer_to_size_t)
+          create_topic_results = TopicResult.create_topic_results_from_array(pointer_to_size_t.read_int, create_topic_result_array)
+          create_topic_handle_ptr = Rdkafka::Bindings.rd_kafka_event_opaque(event_ptr)
+
+          if create_topic_handle = Rdkafka::Admin::CreateTopicHandle.remove(create_topic_handle_ptr.address)
+            unless resolve_operation_error(event_ptr, create_topic_handle)
+              create_topic_handle[:response] = create_topic_results[0].result_error
+              create_topic_handle.result = Rdkafka::Admin::CreateTopicReport.new(
+                create_topic_results[0].error_string,
+                create_topic_results[0].result_name
+              )
+              create_topic_handle.broker_message = create_topic_handle.result.error_string
+
+              create_topic_handle.unlock
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/rdkafka/callbacks/delete_acl_handler.rb

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+module Rdkafka
+  module Callbacks
+    # Handles `RD_KAFKA_EVENT_DELETEACLS_RESULT` events
+    # @private
+    class DeleteAclHandler < BaseHandler
+      class << self
+        # Resolves the delete-ACL handle from its result event
+        # @param event_ptr [FFI::Pointer] pointer to the event
+        # @return [void]
+        def call(event_ptr)
+          delete_acls_result = Rdkafka::Bindings.rd_kafka_event_DeleteAcls_result(event_ptr)
+
+          # Get the number of acl results
+          pointer_to_size_t = FFI::MemoryPointer.new(:size_t)
+          delete_acl_result_responses = Rdkafka::Bindings.rd_kafka_DeleteAcls_result_responses(delete_acls_result, pointer_to_size_t)
+          delete_acl_results = DeleteAclResult.delete_acl_results_from_array(pointer_to_size_t.read_int, delete_acl_result_responses)
+          delete_acl_handle_ptr = Rdkafka::Bindings.rd_kafka_event_opaque(event_ptr)
+
+          if delete_acl_handle = Rdkafka::Admin::DeleteAclHandle.remove(delete_acl_handle_ptr.address)
+            unless resolve_operation_error(event_ptr, delete_acl_handle)
+              delete_acl_handle[:response] = delete_acl_results[0].result_error
+              delete_acl_handle.broker_message = read_event_string(delete_acl_results[0].error_string)
+
+              delete_acl_handle.result = if delete_acl_results[0].result_error == Rdkafka::Bindings::RD_KAFKA_RESP_ERR_NO_ERROR
+                Rdkafka::Admin::DeleteAclReport.new(
+                  matching_acls: delete_acl_results[0].matching_acls,
+                  matching_acls_count: delete_acl_results[0].matching_acls_count
+                )
+              else
+                Rdkafka::Admin::DeleteAclReport.new(matching_acls: FFI::Pointer::NULL, matching_acls_count: 0)
+              end
+
+              delete_acl_handle.unlock
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/rdkafka/callbacks/delete_groups_handler.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+module Rdkafka
+  module Callbacks
+    # Handles `RD_KAFKA_EVENT_DELETEGROUPS_RESULT` events
+    # @private
+    class DeleteGroupsHandler < BaseHandler
+      class << self
+        # Resolves the delete-groups handle from its result event
+        # @param event_ptr [FFI::Pointer] pointer to the event
+        # @return [void]
+        def call(event_ptr)
+          delete_groups_result = Rdkafka::Bindings.rd_kafka_event_DeleteGroups_result(event_ptr)
+
+          # Get the number of delete group results
+          pointer_to_size_t = FFI::MemoryPointer.new(:size_t)
+          delete_group_result_array = Rdkafka::Bindings.rd_kafka_DeleteGroups_result_groups(delete_groups_result, pointer_to_size_t)
+          delete_group_results = GroupResult.create_group_results_from_array(pointer_to_size_t.read_int, delete_group_result_array)
+          delete_group_handle_ptr = Rdkafka::Bindings.rd_kafka_event_opaque(event_ptr)
+
+          if (delete_group_handle = Rdkafka::Admin::DeleteGroupsHandle.remove(delete_group_handle_ptr.address))
+            unless resolve_operation_error(event_ptr, delete_group_handle)
+              delete_group_handle[:response] = delete_group_results[0].result_error
+              delete_group_handle.result = Rdkafka::Admin::DeleteGroupsReport.new(
+                delete_group_results[0].error_string,
+                delete_group_results[0].result_name
+              )
+              delete_group_handle.broker_message = delete_group_handle.result.error_string
+
+              delete_group_handle.unlock
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/rdkafka/callbacks/delete_records_handler.rb

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+module Rdkafka
+  module Callbacks
+    # Handles `RD_KAFKA_EVENT_DELETERECORDS_RESULT` events
+    # @private
+    class DeleteRecordsHandler < BaseHandler
+      class << self
+        # Resolves the delete-records handle from its result event
+        # @param event_ptr [FFI::Pointer] pointer to the event
+        # @return [void]
+        def call(event_ptr)
+          result_ptr = Rdkafka::Bindings.rd_kafka_event_DeleteRecords_result(event_ptr)
+          handle_ptr = Rdkafka::Bindings.rd_kafka_event_opaque(event_ptr)
+
+          return unless (handle = Rdkafka::Admin::DeleteRecordsHandle.remove(handle_ptr.address))
+
+          # An operation-level error (e.g. timeout or a closed client) is delivered on the event
+          # itself, with no per-partition result to parse.
+          return if resolve_operation_error(event_ptr, handle)
+
+          handle[:response] = Rdkafka::Bindings::RD_KAFKA_RESP_ERR_NO_ERROR
+
+          # Parsing must copy everything out of event-owned memory before the event is destroyed.
+          # An exception here is captured and re-raised on the waiting thread, since it cannot
+          # unwind through librdkafka native frames.
+          handle.result = begin
+            Rdkafka::Admin::DeleteRecordsReport.new(result_ptr)
+          rescue => e
+            e
+          end
+
+          handle.unlock
+        end
+      end
+    end
+  end
+end

data/lib/rdkafka/callbacks/delete_topic_handler.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+module Rdkafka
+  module Callbacks
+    # Handles `RD_KAFKA_EVENT_DELETETOPICS_RESULT` events
+    # @private
+    class DeleteTopicHandler < BaseHandler
+      class << self
+        # Resolves the delete-topic handle from its result event
+        # @param event_ptr [FFI::Pointer] pointer to the event
+        # @return [void]
+        def call(event_ptr)
+          delete_topics_result = Rdkafka::Bindings.rd_kafka_event_DeleteTopics_result(event_ptr)
+
+          # Get the number of topic results
+          pointer_to_size_t = FFI::MemoryPointer.new(:size_t)
+          delete_topic_result_array = Rdkafka::Bindings.rd_kafka_DeleteTopics_result_topics(delete_topics_result, pointer_to_size_t)
+          delete_topic_results = TopicResult.create_topic_results_from_array(pointer_to_size_t.read_int, delete_topic_result_array)
+          delete_topic_handle_ptr = Rdkafka::Bindings.rd_kafka_event_opaque(event_ptr)
+
+          if delete_topic_handle = Rdkafka::Admin::DeleteTopicHandle.remove(delete_topic_handle_ptr.address)
+            unless resolve_operation_error(event_ptr, delete_topic_handle)
+              delete_topic_handle[:response] = delete_topic_results[0].result_error
+              delete_topic_handle.result = Rdkafka::Admin::DeleteTopicReport.new(
+                delete_topic_results[0].error_string,
+                delete_topic_results[0].result_name
+              )
+              delete_topic_handle.broker_message = delete_topic_handle.result.error_string
+
+              delete_topic_handle.unlock
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/rdkafka/callbacks/describe_acl_handler.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+module Rdkafka
+  module Callbacks
+    # Handles `RD_KAFKA_EVENT_DESCRIBEACLS_RESULT` events
+    # @private
+    class DescribeAclHandler < BaseHandler
+      class << self
+        # Resolves the describe-ACL handle from its result event
+        # @param event_ptr [FFI::Pointer] pointer to the event
+        # @return [void]
+        def call(event_ptr)
+          describe_acl = DescribeAclResult.new(event_ptr)
+          describe_acl_handle_ptr = Rdkafka::Bindings.rd_kafka_event_opaque(event_ptr)
+
+          if describe_acl_handle = Rdkafka::Admin::DescribeAclHandle.remove(describe_acl_handle_ptr.address)
+            describe_acl_handle[:response] = describe_acl.result_error
+            describe_acl_handle.broker_message = read_event_string(describe_acl.error_string)
+
+            describe_acl_handle.result = if describe_acl.result_error == Rdkafka::Bindings::RD_KAFKA_RESP_ERR_NO_ERROR
+              Rdkafka::Admin::DescribeAclReport.new(
+                acls: describe_acl.matching_acls,
+                acls_count: describe_acl.matching_acls_count
+              )
+            else
+              Rdkafka::Admin::DescribeAclReport.new(acls: FFI::Pointer::NULL, acls_count: 0)
+            end
+
+            describe_acl_handle.unlock
+          end
+        end
+      end
+    end
+  end
+end

data/lib/rdkafka/callbacks/describe_configs_handler.rb

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+module Rdkafka
+  module Callbacks
+    # Handles `RD_KAFKA_EVENT_DESCRIBECONFIGS_RESULT` events
+    # @private
+    class DescribeConfigsHandler < BaseHandler
+      class << self
+        # Resolves the describe-configs handle from its result event
+        # @param event_ptr [FFI::Pointer] pointer to the event
+        # @return [void]
+        def call(event_ptr)
+          describe_configs = DescribeConfigsResult.new(event_ptr)
+          describe_configs_handle_ptr = Rdkafka::Bindings.rd_kafka_event_opaque(event_ptr)
+
+          if describe_configs_handle = Rdkafka::Admin::DescribeConfigsHandle.remove(describe_configs_handle_ptr.address)
+            describe_configs_handle[:response] = describe_configs.result_error
+            describe_configs_handle.broker_message = read_event_string(describe_configs.error_string)
+
+            # Parsing can raise on per-resource errors. The exception is captured and re-raised on
+            # the waiting thread, since an exception leaving this callback would unwind through
+            # librdkafka native frames
+            describe_configs_handle.result = begin
+              if describe_configs.result_error == Rdkafka::Bindings::RD_KAFKA_RESP_ERR_NO_ERROR
+                Rdkafka::Admin::DescribeConfigsReport.new(
+                  config_entries: describe_configs.results,
+                  entry_count: describe_configs.results_count
+                )
+              else
+                Rdkafka::Admin::DescribeConfigsReport.new(config_entries: FFI::Pointer::NULL, entry_count: 0)
+              end
+            rescue => e
+              e
+            end
+
+            describe_configs_handle.unlock
+          end
+        end
+      end
+    end
+  end
+end

data/lib/rdkafka/callbacks/incremental_alter_configs_handler.rb

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+module Rdkafka
+  module Callbacks
+    # Handles `RD_KAFKA_EVENT_INCREMENTALALTERCONFIGS_RESULT` events
+    # @private
+    class IncrementalAlterConfigsHandler < BaseHandler
+      class << self
+        # Resolves the incremental-alter-configs handle from its result event
+        # @param event_ptr [FFI::Pointer] pointer to the event
+        # @return [void]
+        def call(event_ptr)
+          incremental_alter = IncrementalAlterConfigsResult.new(event_ptr)
+          incremental_alter_handle_ptr = Rdkafka::Bindings.rd_kafka_event_opaque(event_ptr)
+
+          if incremental_alter_handle = Rdkafka::Admin::IncrementalAlterConfigsHandle.remove(incremental_alter_handle_ptr.address)
+            incremental_alter_handle[:response] = incremental_alter.result_error
+            incremental_alter_handle.broker_message = read_event_string(incremental_alter.error_string)
+
+            # Parsing can raise on per-resource errors. The exception is captured and re-raised on
+            # the waiting thread, since an exception leaving this callback would unwind through
+            # librdkafka native frames
+            incremental_alter_handle.result = begin
+              if incremental_alter.result_error == Rdkafka::Bindings::RD_KAFKA_RESP_ERR_NO_ERROR
+                Rdkafka::Admin::IncrementalAlterConfigsReport.new(
+                  config_entries: incremental_alter.results,
+                  entry_count: incremental_alter.results_count
+                )
+              else
+                Rdkafka::Admin::IncrementalAlterConfigsReport.new(config_entries: FFI::Pointer::NULL, entry_count: 0)
+              end
+            rescue => e
+              e
+            end
+
+            incremental_alter_handle.unlock
+          end
+        end
+      end
+    end
+  end
+end