rdkafka 0.14.0 → 0.15.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 59f5b664693b87cd66340f821027e45a86c70c0f652c91a0ec6826ba69e02969
-  data.tar.gz: 79e734db66b41d1618a581686df428de75912d06d1e41fe9e2340e63ace3d0da
+  metadata.gz: 8636c80e1798cf24b34cf25a20ca24f35e2951fb179843a3a85a94fe0274ca76
+  data.tar.gz: f115aa7fff4961d42280a7ad6fd78fed40568b936139d588ae2362a2f0f45c25
 SHA512:
-  metadata.gz: cf9821c62c9f958196d78cbe2d8f50b860d06084017cfc3fbf3ffd6c289278d8a8b54f3b40d16d3d3e6c1d71f1112de897cce67cfc09071cb8fa5a0895bd5ed7
-  data.tar.gz: a8e9fab48d749ca62fcdfeda7c2a3d2f85cff7849338cedbe43bbcb8d9300979c0ec44c59a49de8f4efd2ee9a3d7feb3a1fa718f2311c89c6b5aedd99c6d870c
+  metadata.gz: e5b5368a732e42b1c57aff93a7172c95b0bad93ac646dcba495c0509c5b6c29cf8753601d1f04f028c98579846e5db7e7119ae9a6a4cca2f41441316b60b5c9c
+  data.tar.gz: 8596d6944d5151df3ad875d93dbd7cf2aee00c1ded85e053e96880b8c5420ca6ba18a72f57cc867a7bfedf38060be3c9ea4334d79d7a21b2503a078bce1d266a

data/.github/FUNDING.yml

@@ -0,0 +1 @@
+custom: ['https://karafka.io/#become-pro']

data/.github/workflows/ci.yml

@@ -22,16 +22,15 @@ jobs:
       fail-fast: false
       matrix:
         ruby:
-          - '3.3.0-preview2'
+          - '3.3'
           - '3.2'
           - '3.1'
           - '3.1.0'
           - '3.0'
           - '3.0.0'
           - '2.7'
-          - '2.7.0'
         include:
-          - ruby: '3.2'
+          - ruby: '3.3'
             coverage: 'true'
     steps:
       - uses: actions/checkout@v4

data/.ruby-version

@@ -1 +1 @@
-3.2.2
+3.3.0

data/CHANGELOG.md

@@ -1,5 +1,30 @@
 # Rdkafka Changelog
 
+## 0.15.1 (2024-01-30)
+- [Enhancement] Provide support for Nix OS (alexandriainfantino)
+- [Enhancement] Replace `rd_kafka_offset_store` with `rd_kafka_offsets_store` (mensfeld)
+- [Enhancement] Alias `topic_name` as `topic` in the delivery report (mensfeld)
+- [Enhancement] Provide `label` producer handler and report reference for improved traceability (mensfeld)
+- [Enhancement] Include the error when invoking `create_result` on producer handle (mensfeld)
+- [Enhancement] Skip intermediate array creation on delivery report callback execution (one per message) (mensfeld).
+- [Enhancement] Report `-1` instead of `nil` in case `partition_count` failure (mensfeld).
+- [Fix] Fix return type on `#rd_kafka_poll` (mensfeld)
+- [Fix] `uint8_t` does not exist on Apple Silicon (mensfeld)
+- [Fix] Missing ACL `RD_KAFKA_RESOURCE_BROKER` constant reference (mensfeld)
+- [Fix] Partition cache caches invalid nil result for `PARTITIONS_COUNT_TTL` (mensfeld)
+- [Change] Rename `matching_acl_pattern_type` to `matching_acl_resource_pattern_type` to align the whole API (mensfeld)
+
+## 0.15.0 (2023-12-03)
+- **[Feature]** Add `Admin#metadata` (mensfeld)
+- **[Feature]** Add `Admin#create_partitions` (mensfeld)
+- **[Feature]** Add `Admin#delete_group` utility (piotaixr)
+- **[Feature]** Add Create and Delete ACL Feature To Admin Functions (vgnanasekaran)
+- **[Feature]** Support `#assignment_lost?` on a consumer to check for involuntary assignment revocation (mensfeld)
+- [Enhancement] Expose alternative way of managing consumer events via a separate queue (mensfeld) 
+- [Enhancement] **Bump** librdkafka to 2.3.0 (mensfeld)
+- [Enhancement] Increase the `#lag` and `#query_watermark_offsets` default timeouts from 100ms to 1000ms. This will compensate for network glitches and remote clusters operations (mensfeld)
+- [Change] Use `SecureRandom.uuid` instead of `random` for test consumer groups (mensfeld)
+
 ## 0.14.0 (2023-11-21)
 - [Enhancement] Add `raise_response_error` flag to the `Rdkafka::AbstractHandle`.
 - [Enhancement] Allow for setting `statistics_callback` as nil to reset predefined settings configured by a different gem (mensfeld)

data/README.md

@@ -18,21 +18,31 @@ become EOL.
 
 `rdkafka` was written because of the need for a reliable Ruby client for Kafka that supports modern Kafka at [AppSignal](https://appsignal.com). AppSignal runs it in production on very high-traffic systems.
 
-The most important pieces of a Kafka client are implemented. We're
-working towards feature completeness. You can track that here:
-https://github.com/appsignal/rdkafka-ruby/milestone/1
+The most important pieces of a Kafka client are implemented, and we aim to provide all relevant consumer, producer, and admin APIs.
 
 ## Table of content
 
+- [Project Scope](#project-scope)
 - [Installation](#installation)
 - [Usage](#usage)
-  * [Consuming messages](#consuming-messages)
-  * [Producing messages](#producing-messages)
-- [Higher level libraries](#higher-level-libraries)
-  * [Message processing frameworks](#message-processing-frameworks)
-  * [Message publishing libraries](#message-publishing-libraries)
+  * [Consuming Messages](#consuming-messages)
+  * [Producing Messages](#producing-messages)
+- [Higher Level Libraries](#higher-level-libraries)
+  * [Message Processing Frameworks](#message-processing-frameworks)
+  * [Message Publishing Libraries](#message-publishing-libraries)
 - [Development](#development)
 - [Example](#example)
+- [Versions](#versions)
+
+## Project Scope
+
+While rdkafka-ruby aims to simplify the use of librdkafka in Ruby applications, it's important to understand the limitations of this library:
+
+- **No Complex Producers/Consumers**: This library does not intend to offer complex producers or consumers. The aim is to stick closely to the functionalities provided by librdkafka itself.
+
+- **Focus on librdkafka Capabilities**: Features that can be achieved directly in Ruby, without specific needs from librdkafka, are outside the scope of this library.
+
+- **Existing High-Level Functionalities**: Certain high-level functionalities like producer metadata cache and simple consumer are already part of the library. Although they fall slightly outside the primary goal, they will remain part of the contract, given their existing usage.
 
 
 ## Installation
@@ -42,9 +52,9 @@ If you have any problems installing the gem, please open an issue.
 
 ## Usage
 
-See the [documentation](https://www.rubydoc.info/github/appsignal/rdkafka-ruby) for full details on how to use this gem. Two quick examples:
+See the [documentation](https://karafka.io/docs/code/rdkafka-ruby/) for full details on how to use this gem. Two quick examples:
 
-### Consuming messages
+### Consuming Messages
 
 Subscribe to a topic and get messages. Kafka will automatically spread
 the available partitions over consumers with the same group id.
@@ -62,7 +72,7 @@ consumer.each do |message|
 end
 ```
 
-### Producing messages
+### Producing Messages
 
 Produce a number of messages, put the delivery handles in an array, and
 wait for them before exiting. This way the messages will be batched and
@@ -89,41 +99,42 @@ Note that creating a producer consumes some resources that will not be
 released until it `#close` is explicitly called, so be sure to call
 `Config#producer` only as necessary.
 
-## Higher level libraries
+## Higher Level Libraries
 
 Currently, there are two actively developed frameworks based on rdkafka-ruby, that provide higher-level API that can be used to work with Kafka messages and one library for publishing messages.
 
-### Message processing frameworks
+### Message Processing Frameworks
 
 * [Karafka](https://github.com/karafka/karafka) - Ruby and Rails efficient Kafka processing framework.
 * [Racecar](https://github.com/zendesk/racecar) - A simple framework for Kafka consumers in Ruby 
 
-### Message publishing libraries
+### Message Publishing Libraries
 
 * [WaterDrop](https://github.com/karafka/waterdrop) – Standalone Karafka library for producing Kafka messages.
 
 ## Development
 
-A Docker Compose file is included to run Kafka. To run
-that:
+Contributors are encouraged to focus on enhancements that align with the core goal of the library. We appreciate contributions but will likely not accept pull requests for features that:
+
+- Implement functionalities that can achieved using standard Ruby capabilities without changes to the underlying rdkafka-ruby bindings.
+- Deviate significantly from the primary aim of providing librdkafka bindings with Ruby-friendly interfaces.
+
+A Docker Compose file is included to run Kafka. To run that:
 
 ```
 docker-compose up
 ```
 
-Run `bundle` and `cd ext && bundle exec rake && cd ..` to download and
-compile `librdkafka`.
+Run `bundle` and `cd ext && bundle exec rake && cd ..` to download and compile `librdkafka`.
 
-You can then run `bundle exec rspec` to run the tests. To see rdkafka
-debug output:
+You can then run `bundle exec rspec` to run the tests. To see rdkafka debug output:
 
 ```
 DEBUG_PRODUCER=true bundle exec rspec
 DEBUG_CONSUMER=true bundle exec rspec
 ```
 
-After running the tests, you can bring the cluster down to start with a
-clean slate:
+After running the tests, you can bring the cluster down to start with a clean slate:
 
 ```
 docker-compose down
@@ -137,3 +148,14 @@ To see everything working, run these in separate tabs:
 bundle exec rake consume_messages
 bundle exec rake produce_messages
 ```
+
+## Versions
+
+| rdkafka-ruby | librdkafka |
+|-|-|
+| 0.15.0 (2023-12-03) | 2.3.0 (2023-10-25) |
+| 0.14.0 (2023-11-21) | 2.2.0 (2023-07-12) |
+| 0.13.0 (2023-07-24) | 2.0.2 (2023-01-20) |
+| 0.12.0 (2022-06-17) | 1.9.0 (2022-06-16) |
+| 0.11.0 (2021-11-17) | 1.8.2 (2021-10-18) |
+| 0.10.0 (2021-09-07) | 1.5.0 (2020-07-20) |

data/docker-compose.yml

@@ -3,7 +3,7 @@ version: '2'
 services:
   kafka:
     container_name: kafka
-    image: confluentinc/cp-kafka:7.5.2
+    image: confluentinc/cp-kafka:7.5.3
 
     ports:
       - 9092:9092
@@ -23,3 +23,5 @@ services:
       KAFKA_AUTO_CREATE_TOPICS_ENABLE: 'true'
       KAFKA_TRANSACTION_STATE_LOG_REPLICATION_FACTOR: 1
       KAFKA_TRANSACTION_STATE_LOG_MIN_ISR: 1
+      KAFKA_ALLOW_EVERYONE_IF_NO_ACL_FOUND: "true"
+      KAFKA_AUTHORIZER_CLASS_NAME: org.apache.kafka.metadata.authorizer.StandardAuthorizer

data/ext/Rakefile

@@ -1,40 +1,57 @@
 # frozen_string_literal: true
 
 require File.expand_path('../../lib/rdkafka/version', __FILE__)
-require "mini_portile2"
 require "fileutils"
 require "open-uri"
 
 task :default => :clean do
-  # Download and compile librdkafka
-  recipe = MiniPortile.new("librdkafka", Rdkafka::LIBRDKAFKA_VERSION)
+  # For nix users, nix can't locate the file paths because the packages it's requiring aren't managed by the system but are
+  # managed by nix itself, so using the normal file paths doesn't work for nix users.
+  #
+  # Mini_portile causes an issue because it's dependencies are downloaded on the fly and therefore don't exist/aren't
+  # accessible in the nix environment
+  if ENV.fetch('RDKAFKA_EXT_PATH', '').empty?
+    # Download and compile librdkafka if RDKAFKA_EXT_PATH is not set
+    require "mini_portile2"
+    recipe = MiniPortile.new("librdkafka", Rdkafka::LIBRDKAFKA_VERSION)
 
-  # Use default homebrew openssl if we're on mac and the directory exists
-  # and each of flags is not empty
-  if recipe.host&.include?("darwin") && system("which brew &> /dev/null") && Dir.exist?("#{homebrew_prefix = %x(brew --prefix openssl).strip}")
-    ENV["CPPFLAGS"] = "-I#{homebrew_prefix}/include" unless ENV["CPPFLAGS"]
-    ENV["LDFLAGS"] = "-L#{homebrew_prefix}/lib" unless ENV["LDFLAGS"]
-  end
+    # Use default homebrew openssl if we're on mac and the directory exists
+    # and each of flags is not empty
+    if recipe.host&.include?("darwin") && system("which brew &> /dev/null") && Dir.exist?("#{homebrew_prefix = %x(brew --prefix openssl).strip}")
+      ENV["CPPFLAGS"] = "-I#{homebrew_prefix}/include" unless ENV["CPPFLAGS"]
+      ENV["LDFLAGS"] = "-L#{homebrew_prefix}/lib" unless ENV["LDFLAGS"]
+    end
 
-  recipe.files << {
-    :url => "https://codeload.github.com/confluentinc/librdkafka/tar.gz/v#{Rdkafka::LIBRDKAFKA_VERSION}",
-    :sha256 => Rdkafka::LIBRDKAFKA_SOURCE_SHA256
-  }
-  recipe.configure_options = ["--host=#{recipe.host}"]
-  recipe.cook
-  # Move dynamic library we're interested in
-  if recipe.host.include?('darwin')
-    from_extension = '1.dylib'
-    to_extension   = 'dylib'
+    recipe.files << {
+      :url => "https://codeload.github.com/edenhill/librdkafka/tar.gz/v#{Rdkafka::LIBRDKAFKA_VERSION}",
+      :sha256 => Rdkafka::LIBRDKAFKA_SOURCE_SHA256
+    }
+    recipe.configure_options = ["--host=#{recipe.host}"]
+    recipe.cook
+    # Move dynamic library we're interested in
+    if recipe.host.include?('darwin')
+      from_extension = '1.dylib'
+      to_extension   = 'dylib'
+    else
+      from_extension = 'so.1'
+      to_extension = 'so'
+    end
+    lib_path = File.join(File.dirname(__FILE__), "ports/#{recipe.host}/librdkafka/#{Rdkafka::LIBRDKAFKA_VERSION}/lib/librdkafka.#{from_extension}")
+    FileUtils.mv(lib_path, File.join(File.dirname(__FILE__), "librdkafka.#{to_extension}"))
+    # Cleanup files created by miniportile we don't need in the gem
+    FileUtils.rm_rf File.join(File.dirname(__FILE__), "tmp")
+    FileUtils.rm_rf File.join(File.dirname(__FILE__), "ports")
   else
-    from_extension = 'so.1'
-    to_extension = 'so'
+    # Otherwise, copy existing libraries to ./ext
+    if ENV['RDKAFKA_EXT_PATH'].nil? || ENV['RDKAFKA_EXT_PATH'].empty?
+      raise "RDKAFKA_EXT_PATH must be set in your nix config when running under nix"
+    end
+    files = [
+      File.join(ENV['RDKAFKA_EXT_PATH'], 'lib', 'librdkafka.dylib'),
+      File.join(ENV['RDKAFKA_EXT_PATH'], 'lib', 'librdkafka.so')
+    ]
+    files.each { |ext| FileUtils.cp(ext, File.dirname(__FILE__)) if File.exist?(ext) }
   end
-  lib_path = File.join(File.dirname(__FILE__), "ports/#{recipe.host}/librdkafka/#{Rdkafka::LIBRDKAFKA_VERSION}/lib/librdkafka.#{from_extension}")
-  FileUtils.mv(lib_path, File.join(File.dirname(__FILE__), "librdkafka.#{to_extension}"))
-  # Cleanup files created by miniportile we don't need in the gem
-  FileUtils.rm_rf File.join(File.dirname(__FILE__), "tmp")
-  FileUtils.rm_rf File.join(File.dirname(__FILE__), "ports")
 end
 
 task :clean do

data/lib/rdkafka/admin/acl_binding_result.rb

@@ -0,0 +1,51 @@
+# frozen_string_literal: true
+
+module Rdkafka
+  class Admin
+    # Extracts attributes of rd_kafka_AclBinding_t
+    #
+    class AclBindingResult
+      attr_reader :result_error, :error_string, :matching_acl_resource_type,
+                  :matching_acl_resource_name, :matching_acl_resource_pattern_type,
+                  :matching_acl_principal, :matching_acl_host, :matching_acl_operation,
+                  :matching_acl_permission_type
+
+      # This attribute was initially released under the name that is now an alias
+      # We keep it for backwards compatibility but it was changed for the consistency
+      alias matching_acl_pattern_type matching_acl_resource_pattern_type
+
+      def initialize(matching_acl)
+        rd_kafka_error_pointer = Rdkafka::Bindings.rd_kafka_AclBinding_error(matching_acl)
+        @result_error = Rdkafka::Bindings.rd_kafka_error_code(rd_kafka_error_pointer)
+        error_string = Rdkafka::Bindings.rd_kafka_error_string(rd_kafka_error_pointer)
+
+        if error_string != FFI::Pointer::NULL
+          @error_string = error_string.read_string
+        end
+
+        @matching_acl_resource_type = Rdkafka::Bindings.rd_kafka_AclBinding_restype(matching_acl)
+        matching_acl_resource_name = Rdkafka::Bindings.rd_kafka_AclBinding_name(matching_acl)
+
+        if matching_acl_resource_name != FFI::Pointer::NULL
+          @matching_acl_resource_name = matching_acl_resource_name.read_string
+        end
+
+        @matching_acl_resource_pattern_type = Rdkafka::Bindings.rd_kafka_AclBinding_resource_pattern_type(matching_acl)
+        matching_acl_principal = Rdkafka::Bindings.rd_kafka_AclBinding_principal(matching_acl)
+
+        if matching_acl_principal != FFI::Pointer::NULL
+          @matching_acl_principal = matching_acl_principal.read_string
+        end
+
+        matching_acl_host = Rdkafka::Bindings.rd_kafka_AclBinding_host(matching_acl)
+
+        if matching_acl_host != FFI::Pointer::NULL
+          @matching_acl_host = matching_acl_host.read_string
+        end
+
+        @matching_acl_operation = Rdkafka::Bindings.rd_kafka_AclBinding_operation(matching_acl)
+        @matching_acl_permission_type = Rdkafka::Bindings.rd_kafka_AclBinding_permission_type(matching_acl)
+      end
+    end
+  end
+end

data/lib/rdkafka/admin/create_acl_handle.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+module Rdkafka
+  class Admin
+    class CreateAclHandle < AbstractHandle
+      layout :pending, :bool,
+             :response, :int,
+             :response_string, :pointer
+
+      # @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
+
+      def raise_error
+        raise RdkafkaError.new(
+            self[:response],
+            broker_message: self[:response_string].read_string
+        )
+      end
+    end
+  end
+end

data/lib/rdkafka/admin/create_acl_report.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+module Rdkafka
+  class Admin
+    class CreateAclReport
+
+      # Upon successful creation of Acl RD_KAFKA_RESP_ERR_NO_ERROR - 0 is returned as rdkafka_response
+      # @return [Integer]
+      attr_reader :rdkafka_response
+
+
+      # Upon successful creation of Acl empty string will be returned as rdkafka_response_string
+      # @return [String]
+      attr_reader :rdkafka_response_string
+
+      def initialize(rdkafka_response:, rdkafka_response_string:)
+        @rdkafka_response = rdkafka_response
+        if rdkafka_response_string != FFI::Pointer::NULL
+          @rdkafka_response_string = rdkafka_response_string.read_string
+        end
+      end
+    end
+  end
+end

data/lib/rdkafka/admin/create_partitions_handle.rb

@@ -0,0 +1,27 @@
+module Rdkafka
+  class Admin
+    class CreatePartitionsHandle < AbstractHandle
+      layout :pending, :bool,
+             :response, :int,
+             :error_string, :pointer,
+             :result_name, :pointer
+
+      # @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
+
+      def raise_error
+        raise RdkafkaError.new(
+            self[:response],
+            broker_message: CreateTopicReport.new(self[:error_string], self[:result_name]).error_string
+        )
+      end
+    end
+  end
+end

data/lib/rdkafka/admin/create_partitions_report.rb

@@ -0,0 +1,6 @@
+module Rdkafka
+  class Admin
+    class CreatePartitionsReport < CreateTopicReport
+    end
+  end
+end

data/lib/rdkafka/admin/delete_acl_handle.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+module Rdkafka
+  class Admin
+    class DeleteAclHandle < AbstractHandle
+      layout :pending, :bool,
+             :response, :int,
+             :response_string, :pointer,
+             :matching_acls, :pointer,
+             :matching_acls_count, :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
+
+      def raise_error
+        raise RdkafkaError.new(
+            self[:response],
+            broker_message: self[:response_string].read_string
+        )
+      end
+    end
+  end
+end

data/lib/rdkafka/admin/delete_acl_report.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+module Rdkafka
+  class Admin
+    class DeleteAclReport
+
+      # deleted acls
+      # @return [Rdkafka::Bindings::AclBindingResult]
+      attr_reader :deleted_acls
+
+      def initialize(matching_acls:, matching_acls_count:)
+        @deleted_acls=[]
+        if matching_acls != FFI::Pointer::NULL
+          acl_binding_result_pointers  = matching_acls.read_array_of_pointer(matching_acls_count)
+          (1..matching_acls_count).map do |matching_acl_index|
+            acl_binding_result = AclBindingResult.new(acl_binding_result_pointers[matching_acl_index - 1])
+            @deleted_acls << acl_binding_result
+          end
+        end
+      end
+    end
+  end
+end

data/lib/rdkafka/admin/delete_groups_handle.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+module Rdkafka
+  class Admin
+    class DeleteGroupsHandle < AbstractHandle
+      layout :pending, :bool, # TODO: ???
+             :response, :int,
+             :error_string, :pointer,
+             :result_name, :pointer
+
+      # @return [String] the name of the operation
+      def operation_name
+        "delete groups"
+      end
+
+      def create_result
+        DeleteGroupsReport.new(self[:error_string], self[:result_name])
+      end
+
+      def raise_error
+        raise RdkafkaError.new(
+            self[:response],
+            broker_message: create_result.error_string
+        )
+      end
+    end
+  end
+end

data/lib/rdkafka/admin/delete_groups_report.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+module Rdkafka
+  class Admin
+    class DeleteGroupsReport
+      # Any error message generated from the DeleteTopic
+      # @return [String]
+      attr_reader :error_string
+
+      # The name of the topic deleted
+      # @return [String]
+      attr_reader :result_name
+
+      def initialize(error_string, result_name)
+        if error_string != FFI::Pointer::NULL
+          @error_string = error_string.read_string
+        end
+        if result_name != FFI::Pointer::NULL
+          @result_name = @result_name = result_name.read_string
+        end
+      end
+    end
+  end
+end

data/lib/rdkafka/admin/describe_acl_handle.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+module Rdkafka
+  class Admin
+    class DescribeAclHandle < AbstractHandle
+      layout :pending, :bool,
+             :response, :int,
+             :response_string, :pointer,
+             :acls, :pointer,
+             :acls_count, :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
+
+      def raise_error
+        raise RdkafkaError.new(
+            self[:response],
+            broker_message: self[:response_string].read_string
+        )
+      end
+    end
+  end
+end

data/lib/rdkafka/admin/describe_acl_report.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+module Rdkafka
+  class Admin
+    class DescribeAclReport
+
+      # 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
+
+      def initialize(acls:, acls_count:)
+        @acls=[]
+        if acls != FFI::Pointer::NULL
+          acl_binding_result_pointers  = acls.read_array_of_pointer(acls_count)
+          (1..acls_count).map do |acl_index|
+            acl_binding_result = AclBindingResult.new(acl_binding_result_pointers[acl_index - 1])
+            @acls << acl_binding_result
+          end
+        end
+      end
+    end
+  end
+end