rdkafka 0.29.1 → 0.30.0

data/lib/rdkafka/admin.rb

@@ -224,6 +224,78 @@ module Rdkafka
       create_topic_handle
     end
 
+    # Sets the committed offsets of a consumer group from outside the group.
+    #
+    # Kafka requires the group to be empty (no active members) for this to be accepted; when it
+    # is not, the broker rejects the request and the handle raises with `group_not_empty` rather
+    # than reporting success.
+    #
+    # @param group_id [String] the group whose offsets we want to set
+    # @param topic_partition_list [TopicPartitionList] partitions with the offsets to commit
+    # @return [AlterConsumerGroupOffsetsHandle] handle that can be used to wait for the result
+    # @raise [RdkafkaError] when altering the offsets fails
+    def alter_consumer_group_offsets(group_id, topic_partition_list)
+      closed_admin_check(__method__)
+
+      native_tpl = topic_partition_list.to_native_tpl
+
+      begin
+        alter_ptr = Rdkafka::Bindings.rd_kafka_AlterConsumerGroupOffsets_new(
+          FFI::MemoryPointer.from_string(group_id),
+          native_tpl
+        )
+      rescue Exception
+        Rdkafka::Bindings.rd_kafka_topic_partition_list_destroy(native_tpl)
+        raise
+      end
+
+      # librdkafka copies the list into the request object, so ours is no longer needed
+      Rdkafka::Bindings.rd_kafka_topic_partition_list_destroy(native_tpl)
+
+      enqueue_group_offsets_op(
+        request_ptr: alter_ptr,
+        handle: AlterConsumerGroupOffsetsHandle.new,
+        admin_op: Rdkafka::Bindings::RD_KAFKA_ADMIN_OP_ALTERCONSUMERGROUPOFFSETS,
+        destroy: Rdkafka::Bindings.method(:rd_kafka_AlterConsumerGroupOffsets_destroy),
+        enqueue: Rdkafka::Bindings.method(:rd_kafka_AlterConsumerGroupOffsets)
+      )
+    end
+
+    # Deletes the committed offsets of specific partitions of a consumer group, leaving the
+    # group and its remaining offsets in place.
+    #
+    # This is the partition scoped counterpart of {#delete_group}, which removes the whole group.
+    #
+    # @param group_id [String] the group whose offsets we want to delete
+    # @param topic_partition_list [TopicPartitionList] partitions whose offsets to delete
+    # @return [DeleteConsumerGroupOffsetsHandle] handle that can be used to wait for the result
+    # @raise [RdkafkaError] when deleting the offsets fails
+    def delete_consumer_group_offsets(group_id, topic_partition_list)
+      closed_admin_check(__method__)
+
+      native_tpl = topic_partition_list.to_native_tpl
+
+      begin
+        delete_ptr = Rdkafka::Bindings.rd_kafka_DeleteConsumerGroupOffsets_new(
+          FFI::MemoryPointer.from_string(group_id),
+          native_tpl
+        )
+      rescue Exception
+        Rdkafka::Bindings.rd_kafka_topic_partition_list_destroy(native_tpl)
+        raise
+      end
+
+      Rdkafka::Bindings.rd_kafka_topic_partition_list_destroy(native_tpl)
+
+      enqueue_group_offsets_op(
+        request_ptr: delete_ptr,
+        handle: DeleteConsumerGroupOffsetsHandle.new,
+        admin_op: Rdkafka::Bindings::RD_KAFKA_ADMIN_OP_DELETECONSUMERGROUPOFFSETS,
+        destroy: Rdkafka::Bindings.method(:rd_kafka_DeleteConsumerGroupOffsets_destroy),
+        enqueue: Rdkafka::Bindings.method(:rd_kafka_DeleteConsumerGroupOffsets)
+      )
+    end
+
     # Deletes a consumer group
     #
     # @param group_id [String] the group id to delete
@@ -898,35 +970,64 @@ module Rdkafka
       handle[:pending] = true
       handle[:response] = Rdkafka::Bindings::RD_KAFKA_PARTITION_UA
 
-      queue_ptr = @native_kafka.with_inner do |inner|
-        Rdkafka::Bindings.rd_kafka_queue_get_background(inner)
-      end
+      # All native allocation happens inside the begin so a raise at any point (a null background
+      # queue, a non-String resource name making `from_string` raise mid-build, etc.) is cleaned up
+      # by the ensure rather than leaking the queue, the AdminOptions, the handle and the
+      # ConfigResources already built.
+      queue_ptr = nil
+      admin_options_ptr = nil
+      pointer_array = []
+      registered = false
 
-      if queue_ptr.null?
-        raise Rdkafka::Config::ConfigError.new("rd_kafka_queue_get_background was NULL")
-      end
+      begin
+        queue_ptr = @native_kafka.with_inner do |inner|
+          Rdkafka::Bindings.rd_kafka_queue_get_background(inner)
+        end
 
-      admin_options_ptr = @native_kafka.with_inner do |inner|
-        Rdkafka::Bindings.rd_kafka_AdminOptions_new(
-          inner,
-          Rdkafka::Bindings::RD_KAFKA_ADMIN_OP_DESCRIBECONFIGS
-        )
-      end
+        if queue_ptr.null?
+          raise Rdkafka::Config::ConfigError.new("rd_kafka_queue_get_background was NULL")
+        end
 
-      DescribeConfigsHandle.register(handle)
-      Rdkafka::Bindings.rd_kafka_AdminOptions_set_opaque(admin_options_ptr, handle.to_ptr)
+        admin_options_ptr = @native_kafka.with_inner do |inner|
+          Rdkafka::Bindings.rd_kafka_AdminOptions_new(
+            inner,
+            Rdkafka::Bindings::RD_KAFKA_ADMIN_OP_DESCRIBECONFIGS
+          )
+        end
 
-      pointer_array = parsed_resources.map do |resource_type, resource_name|
-        Rdkafka::Bindings.rd_kafka_ConfigResource_new(
-          resource_type,
-          FFI::MemoryPointer.from_string(resource_name)
-        )
-      end
+        # A NULL AdminOptions would segfault the moment we set its opaque pointer, so reject it
+        # before registering the handle (the ensure frees the queue already acquired).
+        if admin_options_ptr.null?
+          raise Rdkafka::Config::ConfigError.new("rd_kafka_AdminOptions_new was NULL")
+        end
 
-      configs_array_ptr = FFI::MemoryPointer.new(:pointer, pointer_array.size)
-      configs_array_ptr.write_array_of_pointer(pointer_array)
+        DescribeConfigsHandle.register(handle)
+        registered = true
+        Rdkafka::Bindings.rd_kafka_AdminOptions_set_opaque(admin_options_ptr, handle.to_ptr)
+
+        # Build resources one at a time so a raise on a later element still leaves the earlier ones
+        # in pointer_array for the ensure to destroy.
+        parsed_resources.each do |resource_type, resource_name|
+          resource_ptr = Rdkafka::Bindings.rd_kafka_ConfigResource_new(
+            resource_type,
+            FFI::MemoryPointer.from_string(resource_name)
+          )
+
+          # librdkafka returns NULL for an empty resource name or a negative resource type. Passing
+          # NULL on to DescribeConfigs and then destroying it both dereference NULL and segfault, so
+          # reject it here (the ensure frees everything already built).
+          if resource_ptr.null?
+            raise Rdkafka::Config::ConfigError.new(
+              "rd_kafka_ConfigResource_new was NULL for #{resource_name.inspect} (type #{resource_type})"
+            )
+          end
+
+          pointer_array << resource_ptr
+        end
+
+        configs_array_ptr = FFI::MemoryPointer.new(:pointer, pointer_array.size)
+        configs_array_ptr.write_array_of_pointer(pointer_array)
 
-      begin
         @native_kafka.with_inner do |inner|
           Rdkafka::Bindings.rd_kafka_DescribeConfigs(
             inner,
@@ -937,18 +1038,20 @@ module Rdkafka
           )
         end
       rescue Exception
-        DescribeConfigsHandle.remove(handle.to_ptr.address)
+        DescribeConfigsHandle.remove(handle.to_ptr.address) if registered
 
         raise
       ensure
-        Rdkafka::Bindings.rd_kafka_AdminOptions_destroy(admin_options_ptr)
-        Rdkafka::Bindings.rd_kafka_queue_destroy(queue_ptr)
+        if admin_options_ptr && !admin_options_ptr.null?
+          Rdkafka::Bindings.rd_kafka_AdminOptions_destroy(admin_options_ptr)
+        end
 
-        if configs_array_ptr
-          Rdkafka::Bindings.rd_kafka_ConfigResource_destroy_array(
-            configs_array_ptr,
-            pointer_array.size
-          )
+        Rdkafka::Bindings.rd_kafka_queue_destroy(queue_ptr) if queue_ptr && !queue_ptr.null?
+
+        pointer_array.each do |config_resource_ptr|
+          next if config_resource_ptr.null?
+
+          Rdkafka::Bindings.rd_kafka_ConfigResource_destroy(config_resource_ptr)
         end
       end
 
@@ -987,66 +1090,91 @@ module Rdkafka
       handle[:pending] = true
       handle[:response] = Rdkafka::Bindings::RD_KAFKA_PARTITION_UA
 
-      queue_ptr = @native_kafka.with_inner do |inner|
-        Rdkafka::Bindings.rd_kafka_queue_get_background(inner)
-      end
+      # All native allocation happens inside the begin so a raise at any point (a null background
+      # queue, a non-String resource name, or FFI marshaling of a config name/value failing while
+      # adding configs) is cleaned up by the ensure rather than leaking the queue, the AdminOptions,
+      # the handle and the ConfigResources already built.
+      queue_ptr = nil
+      admin_options_ptr = nil
+      pointer_array = []
+      registered = false
+      add_error = nil
 
-      if queue_ptr.null?
-        raise Rdkafka::Config::ConfigError.new("rd_kafka_queue_get_background was NULL")
-      end
+      begin
+        queue_ptr = @native_kafka.with_inner do |inner|
+          Rdkafka::Bindings.rd_kafka_queue_get_background(inner)
+        end
 
-      admin_options_ptr = @native_kafka.with_inner do |inner|
-        Rdkafka::Bindings.rd_kafka_AdminOptions_new(
-          inner,
-          Rdkafka::Bindings::RD_KAFKA_ADMIN_OP_INCREMENTALALTERCONFIGS
-        )
-      end
+        if queue_ptr.null?
+          raise Rdkafka::Config::ConfigError.new("rd_kafka_queue_get_background was NULL")
+        end
 
-      IncrementalAlterConfigsHandle.register(handle)
-      Rdkafka::Bindings.rd_kafka_AdminOptions_set_opaque(admin_options_ptr, handle.to_ptr)
+        admin_options_ptr = @native_kafka.with_inner do |inner|
+          Rdkafka::Bindings.rd_kafka_AdminOptions_new(
+            inner,
+            Rdkafka::Bindings::RD_KAFKA_ADMIN_OP_INCREMENTALALTERCONFIGS
+          )
+        end
 
-      add_error = nil
+        # A NULL AdminOptions would segfault the moment we set its opaque pointer, so reject it
+        # before registering the handle (the ensure frees the queue already acquired).
+        if admin_options_ptr.null?
+          raise Rdkafka::Config::ConfigError.new("rd_kafka_AdminOptions_new was NULL")
+        end
 
-      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_type,
-          FFI::MemoryPointer.from_string(resource_name)
-        )
+        IncrementalAlterConfigsHandle.register(handle)
+        registered = true
+        Rdkafka::Bindings.rd_kafka_AdminOptions_set_opaque(admin_options_ptr, handle.to_ptr)
 
-        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,
-            name,
-            op_type,
-            value
+        parsed_resources.each do |resource_type, resource_name, configs|
+          # First build the appropriate resource representation
+          resource_ptr = Rdkafka::Bindings.rd_kafka_ConfigResource_new(
+            resource_type,
+            FFI::MemoryPointer.from_string(resource_name)
           )
 
-          unless error_ptr.null?
-            code = Rdkafka::Bindings.rd_kafka_error_code(error_ptr)
-            Rdkafka::Bindings.rd_kafka_error_destroy(error_ptr)
+          # librdkafka returns NULL for an empty resource name or a negative resource type. Passing
+          # NULL on to add_incremental_config/IncrementalAlterConfigs and then destroying it both
+          # dereference NULL and segfault, so reject it here (the ensure frees everything built).
+          if resource_ptr.null?
+            raise Rdkafka::Config::ConfigError.new(
+              "rd_kafka_ConfigResource_new was NULL for #{resource_name.inspect} (type #{resource_type})"
+            )
+          end
 
-            unless code == Rdkafka::Bindings::RD_KAFKA_RESP_ERR_NO_ERROR
-              add_error ||= Rdkafka::RdkafkaError.new(
-                code,
-                "rd_kafka_ConfigResource_add_incremental_config"
-              )
+          # Track it immediately so a raise while adding its configs still frees it via the ensure.
+          pointer_array << resource_ptr
+
+          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,
+              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
         end
 
-        resource_ptr
-      end
-
-      configs_array_ptr = FFI::MemoryPointer.new(:pointer, pointer_array.size)
-      configs_array_ptr.write_array_of_pointer(pointer_array)
+        configs_array_ptr = FFI::MemoryPointer.new(:pointer, pointer_array.size)
+        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
@@ -1061,18 +1189,20 @@ module Rdkafka
           )
         end
       rescue Exception
-        IncrementalAlterConfigsHandle.remove(handle.to_ptr.address)
+        IncrementalAlterConfigsHandle.remove(handle.to_ptr.address) if registered
 
         raise
       ensure
-        Rdkafka::Bindings.rd_kafka_AdminOptions_destroy(admin_options_ptr)
-        Rdkafka::Bindings.rd_kafka_queue_destroy(queue_ptr)
+        if admin_options_ptr && !admin_options_ptr.null?
+          Rdkafka::Bindings.rd_kafka_AdminOptions_destroy(admin_options_ptr)
+        end
 
-        if configs_array_ptr
-          Rdkafka::Bindings.rd_kafka_ConfigResource_destroy_array(
-            configs_array_ptr,
-            pointer_array.size
-          )
+        Rdkafka::Bindings.rd_kafka_queue_destroy(queue_ptr) if queue_ptr && !queue_ptr.null?
+
+        pointer_array.each do |config_resource_ptr|
+          next if config_resource_ptr.null?
+
+          Rdkafka::Bindings.rd_kafka_ConfigResource_destroy(config_resource_ptr)
         end
       end
 
@@ -1081,6 +1211,54 @@ module Rdkafka
 
     private
 
+    # Shared enqueue path for the two consumer group offset admin operations. They differ only
+    # in their C entry points, so keeping one body avoids two near identical copies of the
+    # queue/handle/options dance and its cleanup.
+    #
+    # @param request_ptr [FFI::Pointer] the op specific request object
+    # @param handle [AbstractHandle] the handle to register and return
+    # @param admin_op [Integer] the RD_KAFKA_ADMIN_OP_* constant for this operation
+    # @param destroy [Method] bound function used to free the request object
+    # @param enqueue [Method] bound function used to enqueue the request
+    # @return [AbstractHandle] the registered handle
+    def enqueue_group_offsets_op(request_ptr:, handle:, admin_op:, destroy:, enqueue:)
+      array_ptr = FFI::MemoryPointer.new(:pointer)
+      array_ptr.write_array_of_pointer([request_ptr])
+
+      queue_ptr = @native_kafka.with_inner do |inner|
+        Rdkafka::Bindings.rd_kafka_queue_get_background(inner)
+      end
+
+      if queue_ptr.null?
+        destroy.call(request_ptr)
+        raise Rdkafka::Config::ConfigError.new("rd_kafka_queue_get_background was NULL")
+      end
+
+      handle[:pending] = true
+      handle[:response] = Rdkafka::Bindings::RD_KAFKA_PARTITION_UA
+      handle.class.register(handle)
+
+      admin_options_ptr = @native_kafka.with_inner do |inner|
+        Rdkafka::Bindings.rd_kafka_AdminOptions_new(inner, admin_op)
+      end
+      Rdkafka::Bindings.rd_kafka_AdminOptions_set_opaque(admin_options_ptr, handle.to_ptr)
+
+      begin
+        @native_kafka.with_inner do |inner|
+          enqueue.call(inner, array_ptr, 1, admin_options_ptr, queue_ptr)
+        end
+      rescue Exception
+        handle.class.remove(handle.to_ptr.address)
+        raise
+      ensure
+        Rdkafka::Bindings.rd_kafka_AdminOptions_destroy(admin_options_ptr)
+        Rdkafka::Bindings.rd_kafka_queue_destroy(queue_ptr)
+        destroy.call(request_ptr)
+      end
+
+      handle
+    end
+
     # Checks if the admin is closed and raises an error if so
     # @param method [Symbol] name of the calling method for error context
     # @raise [ClosedAdminError] when the admin is closed

data/lib/rdkafka/bindings.rb

@@ -161,6 +161,7 @@ module Rdkafka
 
     attach_function :rd_kafka_DescribeConfigs, [:pointer, :pointer, :size_t, :pointer, :pointer], :void, blocking: true
     attach_function :rd_kafka_ConfigResource_new, [:int32, :pointer], :pointer
+    attach_function :rd_kafka_ConfigResource_destroy, [:pointer], :void
     attach_function :rd_kafka_ConfigResource_destroy_array, [:pointer, :int32], :void
     attach_function :rd_kafka_event_DescribeConfigs_result, [:pointer], :pointer
     attach_function :rd_kafka_DescribeConfigs_result_resources, [:pointer, :pointer], :pointer
@@ -191,7 +192,7 @@ module Rdkafka
     RD_KAFKA_ALTER_CONFIG_OP_TYPE_SUBTRACT = 3
 
     # List Offsets
-    RD_KAFKA_ADMIN_OP_LISTOFFSETS = 20
+    RD_KAFKA_ADMIN_OP_LISTOFFSETS = 21
     RD_KAFKA_EVENT_LISTOFFSETS_RESULT = 0x400000
 
     # rd_kafka_IsolationLevel_t
@@ -502,9 +503,31 @@ module Rdkafka
         raise Rdkafka::Config::ConfigError.new("Unknown partitioner: #{partitioner}")
       end
 
-      public_send(method_name, topic_ptr, str_ptr, str.size, partition_count, nil, nil)
+      public_send(method_name, topic_ptr, str_ptr, partition_key_length(str), partition_count, nil, nil)
     end
 
+    # Partition key length as the character count (legacy default).
+    #
+    # @param str [String] the partition key string
+    # @return [Integer]
+    def self.partition_key_size(str)
+      str.size
+    end
+
+    # Partition key length as the byte count, which is what librdkafka hashes (UTF-8 bytes copied
+    # into the key pointer) and what other Kafka clients use.
+    #
+    # @param str [String] the partition key string
+    # @return [Integer]
+    def self.partition_key_bytesize(str)
+      str.bytesize
+    end
+
+    # Length of the partition key passed to librdkafka. Aliased to one of the methods above by
+    # `Rdkafka::Config.partitioner_key_uses_bytesize=`, so the per-message path does not check the
+    # setting on every call.
+    singleton_class.alias_method :partition_key_length, :partition_key_size
+
     # Create Topics
     RD_KAFKA_ADMIN_OP_CREATETOPICS = 1   # rd_kafka_admin_op_t
     RD_KAFKA_EVENT_CREATETOPICS_RESULT = 100 # rd_kafka_event_type_t
@@ -546,6 +569,26 @@ 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**
 
+    # Alter Consumer Group Offsets
+    RD_KAFKA_ADMIN_OP_ALTERCONSUMERGROUPOFFSETS = 15   # rd_kafka_admin_op_t
+    RD_KAFKA_EVENT_ALTERCONSUMERGROUPOFFSETS_RESULT = 0x10000 # rd_kafka_event_type_t
+
+    attach_function :rd_kafka_AlterConsumerGroupOffsets, [:pointer, :pointer, :size_t, :pointer, :pointer], :void, blocking: true
+    attach_function :rd_kafka_AlterConsumerGroupOffsets_new, [:pointer, :pointer], :pointer, blocking: true # const char*, const rd_kafka_topic_partition_list_t* => rd_kafka_AlterConsumerGroupOffsets_t*
+    attach_function :rd_kafka_AlterConsumerGroupOffsets_destroy, [:pointer], :void, blocking: true
+    attach_function :rd_kafka_event_AlterConsumerGroupOffsets_result, [:pointer], :pointer, blocking: true # rd_kafka_event_t* => rd_kafka_AlterConsumerGroupOffsets_result_t*
+    attach_function :rd_kafka_AlterConsumerGroupOffsets_result_groups, [:pointer, :pointer], :pointer, blocking: true # rd_kafka_AlterConsumerGroupOffsets_result_t*, size_t* => rd_kafka_group_result_t**
+
+    # Delete Consumer Group Offsets
+    RD_KAFKA_ADMIN_OP_DELETECONSUMERGROUPOFFSETS = 8   # rd_kafka_admin_op_t
+    RD_KAFKA_EVENT_DELETECONSUMERGROUPOFFSETS_RESULT = 107 # rd_kafka_event_type_t
+
+    attach_function :rd_kafka_DeleteConsumerGroupOffsets, [:pointer, :pointer, :size_t, :pointer, :pointer], :void, blocking: true
+    attach_function :rd_kafka_DeleteConsumerGroupOffsets_new, [:pointer, :pointer], :pointer, blocking: true # const char*, const rd_kafka_topic_partition_list_t* => rd_kafka_DeleteConsumerGroupOffsets_t*
+    attach_function :rd_kafka_DeleteConsumerGroupOffsets_destroy, [:pointer], :void, blocking: true
+    attach_function :rd_kafka_event_DeleteConsumerGroupOffsets_result, [:pointer], :pointer, blocking: true # rd_kafka_event_t* => rd_kafka_DeleteConsumerGroupOffsets_result_t*
+    attach_function :rd_kafka_DeleteConsumerGroupOffsets_result_groups, [:pointer, :pointer], :pointer, blocking: true # rd_kafka_DeleteConsumerGroupOffsets_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
@@ -695,5 +738,6 @@ module Rdkafka
 
     attach_function :rd_kafka_group_result_error, [:pointer], NativeError.by_ref # rd_kafka_group_result_t* => rd_kafka_error_t*
     attach_function :rd_kafka_group_result_name, [:pointer], :pointer
+    attach_function :rd_kafka_group_result_partitions, [:pointer], :pointer # rd_kafka_group_result_t* => rd_kafka_topic_partition_list_t*
   end
 end

data/lib/rdkafka/callbacks/alter_consumer_group_offsets_handler.rb

@@ -0,0 +1,65 @@
+# frozen_string_literal: true
+
+module Rdkafka
+  module Callbacks
+    # Handles `RD_KAFKA_EVENT_ALTERCONSUMERGROUPOFFSETS_RESULT` events
+    # @private
+    class AlterConsumerGroupOffsetsHandler < BaseHandler
+      class << self
+        # Resolves the alter consumer group offsets handle from its result event
+        # @param event_ptr [FFI::Pointer] pointer to the event
+        # @return [void]
+        def call(event_ptr)
+          result = Rdkafka::Bindings.rd_kafka_event_AlterConsumerGroupOffsets_result(event_ptr)
+
+          pointer_to_size_t = FFI::MemoryPointer.new(:size_t)
+          group_result_array = Rdkafka::Bindings.rd_kafka_AlterConsumerGroupOffsets_result_groups(result, pointer_to_size_t)
+          group_results = GroupResult.create_group_results_from_array(pointer_to_size_t.read_int, group_result_array)
+          handle_ptr = Rdkafka::Bindings.rd_kafka_event_opaque(event_ptr)
+
+          if (handle = Rdkafka::Admin::AlterConsumerGroupOffsetsHandle.remove(handle_ptr.address))
+            unless resolve_operation_error(event_ptr, handle)
+              group_result = group_results[0]
+
+              # librdkafka only supports one group per invocation, so a missing group result
+              # means the broker returned nothing to act on rather than a partial success.
+              if group_result.nil?
+                handle[:response] = Rdkafka::Bindings::RD_KAFKA_RESP_ERR_NO_ERROR
+                handle.result = Rdkafka::Admin::AlterConsumerGroupOffsetsReport.new(
+                  FFI::Pointer::NULL,
+                  FFI::Pointer::NULL
+                )
+              else
+                report = Rdkafka::Admin::AlterConsumerGroupOffsetsReport.new(
+                  group_result.error_string,
+                  group_result.result_name,
+                  Rdkafka::Bindings.rd_kafka_group_result_partitions(group_result_array.read_pointer)
+                )
+                handle.result = report
+
+                # Kafka reports a rejected offset change per partition, leaving the group level
+                # error unset - a group with live members comes back with the group error NULL
+                # and `unknown_member_id` on each partition. Resolving on the group error alone
+                # would hand back a report that looks like success, so any failed partition has
+                # to fail the handle too.
+                failed = report.partitions.find { |partition| partition[:error] }
+
+                if !group_result.result_error.zero?
+                  handle[:response] = group_result.result_error
+                  handle.broker_message = report.error_string
+                elsif failed
+                  handle[:response] = failed[:error].rdkafka_response
+                  handle.broker_message = "Failed for partition #{failed[:partition]} of '#{failed[:topic]}'"
+                else
+                  handle[:response] = Rdkafka::Bindings::RD_KAFKA_RESP_ERR_NO_ERROR
+                end
+              end
+
+              handle.unlock
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/rdkafka/callbacks/delete_consumer_group_offsets_handler.rb

@@ -0,0 +1,65 @@
+# frozen_string_literal: true
+
+module Rdkafka
+  module Callbacks
+    # Handles `RD_KAFKA_EVENT_DELETECONSUMERGROUPOFFSETS_RESULT` events
+    # @private
+    class DeleteConsumerGroupOffsetsHandler < BaseHandler
+      class << self
+        # Resolves the delete consumer group offsets handle from its result event
+        # @param event_ptr [FFI::Pointer] pointer to the event
+        # @return [void]
+        def call(event_ptr)
+          result = Rdkafka::Bindings.rd_kafka_event_DeleteConsumerGroupOffsets_result(event_ptr)
+
+          pointer_to_size_t = FFI::MemoryPointer.new(:size_t)
+          group_result_array = Rdkafka::Bindings.rd_kafka_DeleteConsumerGroupOffsets_result_groups(result, pointer_to_size_t)
+          group_results = GroupResult.create_group_results_from_array(pointer_to_size_t.read_int, group_result_array)
+          handle_ptr = Rdkafka::Bindings.rd_kafka_event_opaque(event_ptr)
+
+          if (handle = Rdkafka::Admin::DeleteConsumerGroupOffsetsHandle.remove(handle_ptr.address))
+            unless resolve_operation_error(event_ptr, handle)
+              group_result = group_results[0]
+
+              # librdkafka only supports one group per invocation, so a missing group result
+              # means the broker returned nothing to act on rather than a partial success.
+              if group_result.nil?
+                handle[:response] = Rdkafka::Bindings::RD_KAFKA_RESP_ERR_NO_ERROR
+                handle.result = Rdkafka::Admin::DeleteConsumerGroupOffsetsReport.new(
+                  FFI::Pointer::NULL,
+                  FFI::Pointer::NULL
+                )
+              else
+                report = Rdkafka::Admin::DeleteConsumerGroupOffsetsReport.new(
+                  group_result.error_string,
+                  group_result.result_name,
+                  Rdkafka::Bindings.rd_kafka_group_result_partitions(group_result_array.read_pointer)
+                )
+                handle.result = report
+
+                # Kafka reports a rejected offset change per partition, leaving the group level
+                # error unset - a group with live members comes back with the group error NULL
+                # and `unknown_member_id` on each partition. Resolving on the group error alone
+                # would hand back a report that looks like success, so any failed partition has
+                # to fail the handle too.
+                failed = report.partitions.find { |partition| partition[:error] }
+
+                if !group_result.result_error.zero?
+                  handle[:response] = group_result.result_error
+                  handle.broker_message = report.error_string
+                elsif failed
+                  handle[:response] = failed[:error].rdkafka_response
+                  handle.broker_message = "Failed for partition #{failed[:partition]} of '#{failed[:topic]}'"
+                else
+                  handle[:response] = Rdkafka::Bindings::RD_KAFKA_RESP_ERR_NO_ERROR
+                end
+              end
+
+              handle.unlock
+            end
+          end
+        end
+      end
+    end
+  end
+end