karafka-rdkafka 0.28.0-aarch64-linux-gnu → 0.28.2-aarch64-linux-gnu

data/lib/rdkafka/admin.rb

@@ -108,10 +108,6 @@ module Rdkafka
     # @return [nil]
     # @raise [Rdkafka::ClosedAdminError] if called on a closed admin client
     #
-    # @note This method holds the inner lock until the queue is empty or `:stop` is returned.
-    #   Other admin operations will wait until this method returns.
-    # @note This method is thread-safe as it uses @native_kafka.with_inner synchronization
-    #
     # @example Drain all pending events
     #   admin.events_poll_nb_each { |_count| }
     #
@@ -120,6 +116,9 @@ module Rdkafka
     #   admin.events_poll_nb_each do |_count|
     #     :stop if monotonic_now >= deadline
     #   end
+    # @note This method holds the inner lock until the queue is empty or `:stop` is returned.
+    #   Other admin operations will wait until this method returns.
+    # @note This method is thread-safe as it uses @native_kafka.with_inner synchronization
     def events_poll_nb_each
       closed_admin_check(__method__)
 
@@ -283,6 +282,172 @@ module Rdkafka
       delete_groups_handle
     end
 
+    # Deletes all messages in the given partitions up to (but not including) the given offset.
+    #
+    # The programmatic equivalent of `kafka-delete-records.sh`. Useful for GDPR/right-to-erasure
+    # compliance, clearing out poison messages, or retention cleanup outside of the configured
+    # time/size-based retention policy.
+    #
+    # @param topic_partition_offsets [Hash{String => Array<Hash>}] hash mapping topic names to
+    #   arrays of partition delete specifications. Each specification is a hash with:
+    #   - `:partition` [Integer] partition number
+    #   - `:offset` [Symbol, Integer] delete all messages before this offset (exclusive) - an
+    #     integer offset, or `:end` to delete all data currently in the partition
+    #
+    # @return [DeleteRecordsHandle] handle that can be used to wait for the result
+    # @raise [RdkafkaError] when deleting records fails
+    #
+    # @example Delete all messages before offset 100 in one partition, and all data in another
+    #   report = admin.delete_records(
+    #     "my_topic" => [
+    #       { partition: 0, offset: 100 },
+    #       { partition: 1, offset: :end }
+    #     ]
+    #   ).wait(max_wait_timeout_ms: 15_000)
+    #
+    #   report.offsets.to_h
+    #   # => { "my_topic" => [#<Partition @partition=0, @offset=100, @err=0>, ...] }
+    def delete_records(topic_partition_offsets)
+      closed_admin_check(__method__)
+
+      parsed = topic_partition_offsets.flat_map do |topic, partitions|
+        partitions.map do |spec|
+          offset = spec.fetch(:offset)
+
+          native_offset = case offset
+          when :end then Rdkafka::Bindings::RD_KAFKA_OFFSET_END
+          when Integer then offset
+          else
+            raise ArgumentError, "Unknown offset specification: #{offset.inspect}"
+          end
+
+          [topic, spec.fetch(:partition), native_offset]
+        end
+      end
+
+      tpl = Rdkafka::Bindings.rd_kafka_topic_partition_list_new(parsed.size)
+
+      parsed.each do |topic, partition, native_offset|
+        Rdkafka::Bindings.rd_kafka_topic_partition_list_add(tpl, topic, partition)
+        Rdkafka::Bindings.rd_kafka_topic_partition_list_set_offset(tpl, topic, partition, native_offset)
+      end
+
+      # rd_kafka_DeleteRecords_new copies the tpl it is given, so it does not need to (and must
+      # not) outlive this call - it is destroyed below, independently of the wrapping
+      # DeleteRecords_t object.
+      delete_records_ptr = Rdkafka::Bindings.rd_kafka_DeleteRecords_new(tpl)
+      Rdkafka::Bindings.rd_kafka_topic_partition_list_destroy(tpl)
+
+      pointer_array = [delete_records_ptr]
+      records_array_ptr = FFI::MemoryPointer.new(:pointer)
+      records_array_ptr.write_array_of_pointer(pointer_array)
+
+      # Get a pointer to the queue that our request will be enqueued on
+      queue_ptr = @native_kafka.with_inner do |inner|
+        Rdkafka::Bindings.rd_kafka_queue_get_background(inner)
+      end
+      if queue_ptr.null?
+        Rdkafka::Bindings.rd_kafka_DeleteRecords_destroy(delete_records_ptr)
+        raise Rdkafka::Config::ConfigError.new("rd_kafka_queue_get_background was NULL")
+      end
+
+      # Create and register the handle we will return to the caller
+      handle = DeleteRecordsHandle.new
+      handle[:pending] = true
+      handle[:response] = Rdkafka::Bindings::RD_KAFKA_PARTITION_UA
+      DeleteRecordsHandle.register(handle)
+
+      admin_options_ptr = @native_kafka.with_inner do |inner|
+        Rdkafka::Bindings.rd_kafka_AdminOptions_new(inner, Rdkafka::Bindings::RD_KAFKA_ADMIN_OP_DELETERECORDS)
+      end
+      Rdkafka::Bindings.rd_kafka_AdminOptions_set_opaque(admin_options_ptr, handle.to_ptr)
+
+      begin
+        @native_kafka.with_inner do |inner|
+          Rdkafka::Bindings.rd_kafka_DeleteRecords(
+            inner,
+            records_array_ptr,
+            1,
+            admin_options_ptr,
+            queue_ptr
+          )
+        end
+      rescue Exception
+        DeleteRecordsHandle.remove(handle.to_ptr.address)
+        raise
+      ensure
+        Rdkafka::Bindings.rd_kafka_AdminOptions_destroy(admin_options_ptr)
+        Rdkafka::Bindings.rd_kafka_queue_destroy(queue_ptr)
+        Rdkafka::Bindings.rd_kafka_DeleteRecords_destroy(delete_records_ptr)
+      end
+
+      handle
+    end
+
+    # Lists consumer groups cluster-wide.
+    #
+    # librdkafka issues a single `ListConsumerGroups` request that is fanned out to every broker
+    # internally, so the result covers all consumer groups in the cluster, not only those
+    # coordinated by the connected broker.
+    #
+    # @return [ListConsumerGroupsHandle] handle that can be used to wait for the result
+    # @raise [RdkafkaError] when listing the consumer groups fails
+    #
+    # @example List every consumer group in the cluster and print its name and attributes
+    #   report = admin.list_consumer_groups.wait(max_wait_timeout_ms: 15_000)
+    #
+    #   report.groups.each do |group|
+    #     puts "#{group[:group_id]} - #{group[:state_name]} " \
+    #          "(simple: #{group[:is_simple_consumer_group]})"
+    #   end
+    #
+    #   # Any brokers that could not be reached are reported separately
+    #   report.errors.each { |error| warn "partial listing error: #{error.message}" }
+    def list_consumer_groups
+      closed_admin_check(__method__)
+
+      # Get a pointer to the queue that our request will be enqueued on
+      queue_ptr = @native_kafka.with_inner do |inner|
+        Rdkafka::Bindings.rd_kafka_queue_get_background(inner)
+      end
+
+      if queue_ptr.null?
+        raise Rdkafka::Config::ConfigError.new("rd_kafka_queue_get_background was NULL")
+      end
+
+      # Create and register the handle we will return to the caller
+      handle = ListConsumerGroupsHandle.new
+      handle[:pending] = true
+      handle[:response] = Rdkafka::Bindings::RD_KAFKA_PARTITION_UA
+      ListConsumerGroupsHandle.register(handle)
+
+      admin_options_ptr = @native_kafka.with_inner do |inner|
+        Rdkafka::Bindings.rd_kafka_AdminOptions_new(
+          inner,
+          Rdkafka::Bindings::RD_KAFKA_ADMIN_OP_LISTCONSUMERGROUPS
+        )
+      end
+      Rdkafka::Bindings.rd_kafka_AdminOptions_set_opaque(admin_options_ptr, handle.to_ptr)
+
+      begin
+        @native_kafka.with_inner do |inner|
+          Rdkafka::Bindings.rd_kafka_ListConsumerGroups(
+            inner,
+            admin_options_ptr,
+            queue_ptr
+          )
+        end
+      rescue Exception
+        ListConsumerGroupsHandle.remove(handle.to_ptr.address)
+        raise
+      ensure
+        Rdkafka::Bindings.rd_kafka_AdminOptions_destroy(admin_options_ptr)
+        Rdkafka::Bindings.rd_kafka_queue_destroy(queue_ptr)
+      end
+
+      handle
+    end
+
     # Deletes the named topic
     #
     # @param topic_name [String] name of the topic to delete
@@ -345,7 +510,8 @@ module Rdkafka
     #
     # @param topic_name [String] name of the topic
     # @param partition_count [Integer] how many partitions we want to end up with for given topic
-    # @return [CreatePartitionsHandle] Create partitions handle that can be used to wait for the result
+    # @return [CreatePartitionsHandle] Create partitions handle that can be used to wait for the
+    #   result
     # @raise [ConfigError] When the partition count or replication factor are out of valid range
     # @raise [RdkafkaError] When the topic name is invalid or the topic already exists
     # @raise [RdkafkaError] When the topic configuration is invalid
@@ -434,7 +600,8 @@ module Rdkafka
     # @param permission_type [Integer] rd_kafka_AclPermissionType_t value:
     #   - RD_KAFKA_ACL_PERMISSION_TYPE_DENY  = 2
     #   - RD_KAFKA_ACL_PERMISSION_TYPE_ALLOW = 3
-    # @return [CreateAclHandle] Create acl handle that can be used to wait for the result of creating the acl
+    # @return [CreateAclHandle] Create acl handle that can be used to wait for the result of
+    #   creating the acl
     # @raise [RdkafkaError]
     def create_acl(resource_type:, resource_name:, resource_pattern_type:, principal:, host:, operation:, permission_type:)
       closed_admin_check(__method__)
@@ -535,7 +702,8 @@ module Rdkafka
     # @param permission_type [Integer] rd_kafka_AclPermissionType_t value:
     #   - RD_KAFKA_ACL_PERMISSION_TYPE_DENY  = 2
     #   - RD_KAFKA_ACL_PERMISSION_TYPE_ALLOW = 3
-    # @return [DeleteAclHandle] Delete acl handle that can be used to wait for the result of deleting the acl
+    # @return [DeleteAclHandle] Delete acl handle that can be used to wait for the result of
+    #   deleting the acl
     # @raise [RdkafkaError]
     def delete_acl(resource_type:, resource_name:, resource_pattern_type:, principal:, host:, operation:, permission_type:)
       closed_admin_check(__method__)
@@ -638,7 +806,8 @@ module Rdkafka
     # @param permission_type [Integer] rd_kafka_AclPermissionType_t value:
     #   - RD_KAFKA_ACL_PERMISSION_TYPE_DENY  = 2
     #   - RD_KAFKA_ACL_PERMISSION_TYPE_ALLOW = 3
-    # @return [DescribeAclHandle] Describe acl handle that can be used to wait for the result of fetching acls
+    # @return [DescribeAclHandle] Describe acl handle that can be used to wait for the result of
+    #   fetching acls
     # @raise [RdkafkaError]
     def describe_acl(resource_type:, resource_name:, resource_pattern_type:, principal:, host:, operation:, permission_type:)
       closed_admin_check(__method__)
@@ -729,35 +898,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,
@@ -768,18 +966,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
 
@@ -818,61 +1018,86 @@ 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 (build_from_c also
-          # destroys 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)
           )
 
-          error = Rdkafka::RdkafkaError.build_from_c(
-            error_ptr,
-            "rd_kafka_ConfigResource_add_incremental_config"
-          )
+          # 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
 
-          add_error ||= error if error
+          # 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 (build_from_c also
+            # destroys 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
+            )
+
+            error = Rdkafka::RdkafkaError.build_from_c(
+              error_ptr,
+              "rd_kafka_ConfigResource_add_incremental_config"
+            )
+
+            add_error ||= error if error
+          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
@@ -887,18 +1112,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
 

data/lib/rdkafka/bindings.rb

@@ -88,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
@@ -170,6 +170,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
@@ -271,10 +272,11 @@ 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
@@ -343,7 +345,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)
@@ -388,9 +391,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`.
@@ -599,6 +603,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
@@ -661,21 +696,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
@@ -689,7 +727,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