rdkafka 0.30.0-aarch64-linux-gnu → 0.31.0-aarch64-linux-gnu

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 5e13458da0b2a5865398fb599a6c647ec4e248cf6084d2126b1940ff2185125c
-  data.tar.gz: 1839bea67dd286bf132ea896e8eb83aa8747dfce172ac436c04c5e2113fe7c12
+  metadata.gz: 50f9195c8025153b9abeed116aef974797c77e6c7e432dff7feee99382337948
+  data.tar.gz: c03fb2903a11183acf52191cae90a74189e2aa12ab62bc265829cb8d69919d9b
 SHA512:
-  metadata.gz: 16b1a1096b42ff842dc9ebc20cda49678af64271a2552f63c3f01f85417e9c1884ee40a872de9ca76a930ac1e9480c50fbf10f31e992441abdf12c6fdbc34026
-  data.tar.gz: 79ec42c9962284cf42cf033165b1acbf7aa646e1a54f1b2b8677311f8cf26991c7b0b472c1cb98f2c193a8c83ab01a11f7781db6681d07e4c4b80510c9a5cd75
+  metadata.gz: fb85bd66574e527a5236b065362b78be86f3523ea96cb6c8e1b55b86f7d7f913bce62abdf2d6510c578d27baa0b9dacbb80c940bacc34b1954a8e1c5bfd5f459
+  data.tar.gz: 509b190f874ac1413bfc5e4b36b3768b44abc6e0405ba0e11a7b0f0d18756759c9368d75a18c07a5057163718f7d3e5f465262fcabd51d72359e6435c20ad9b6

data/CHANGELOG.md

@@ -1,5 +1,18 @@
 # Rdkafka Changelog
 
+## 0.31.0 (2026-10-09)
+- **[EOL]** Drop Ruby 3.2 support; require Ruby 3.3+.
+- [Feature] Add `status`, `latency` and `broker_id` to `Producer::DeliveryReport`, with `#persisted?`, `#possibly_persisted?` and `#not_persisted?`, so a failed delivery tells whether a retry may duplicate the message.
+- [Feature] Add `Admin#describe_cluster` to get the cluster id, controller and broker nodes (with racks) without a full metadata request.
+- [Feature] Add `Admin#describe_topics` to get topic ids, partition leaders and replicas, and per-topic errors. Both methods can also return the operations the client is authorized to perform.
+- [Feature] Add `Admin#describe_consumer_groups` to read the state, type, coordinator, authorized operations and members (with their current and target partition assignments) of consumer groups.
+- [Enhancement] Bump librdkafka to `2.15.1` for OpenSSL and libcurl security fixes. It changes how IPv6 addresses are formatted and validated against broker certificates.
+- [Enhancement] Bump the bundled OpenSSL to `3.5.9` (LTS) for its security fixes.
+- [Enhancement] Read each pointer field once in `Message#initialize`, saving 3 allocations per consumed message.
+- [Change] Build the precompiled `macos_arm64` library on macOS 26 with the minimum macOS pinned to 14.0, instead of inheriting it from the build host.
+- [Change] Build the precompiled `aarch64-linux-musl` gem on Alpine `3.24` (was `3.23`), matching `x86_64-linux-musl`.
+- [Maintenance] Split `lib/rdkafka/bindings.rb` into per-area files under `lib/rdkafka/bindings/`. `Rdkafka::Bindings` is unchanged.
+
 ## 0.30.0 (2026-09-25)
 - [Feature] Add `Admin#alter_consumer_group_offsets` and `Admin#delete_consumer_group_offsets` to set or clear a consumer group's committed offsets from the admin client.
 - [Enhancement] Bump the bundled zlib to `1.3.2`.
@@ -11,7 +24,7 @@
 - [Fix] Honor the `isolation_level:` argument to `Admin#list_offsets`, which was silently ignored.
 - [Fix] Return correct results for every item of a multi-item topic, partition, group or ACL admin request, not just the first.
 - [Maintenance] Fix a use-after-free in the multi-item admin integration test that read result-name pointers after librdkafka had destroyed the background event, which made it flaky on newer glibc (e.g. Debian trixie).
-- [Maintenance] Stabilize consumer specs on slow CI runners: wait longer for a partition assignment, raise the `TestTopics.create` admin timeout (a timeout there also tripped the leaked-handle guard), and let the long-running consumption spec drain its backlog instead of stopping at a fixed 60s.
+- [Maintenance] Stabilize consumer specs on slow CI runners: wait longer for a partition assignment, raise the `TestTopics.create` admin timeout and drop the fixed 60s limit of the long-running consumption spec.
 - [Maintenance] Raise the `TestTopics.create` admin timeout to 30s so a loaded CI runner no longer hits `create topic timed out` (which also tripped the leaked-handle guard).
 
 ## 0.29.2 (2026-09-11)
@@ -89,7 +102,7 @@
 - [Feature] Support `rd_kafka_ListOffsets` admin API for querying partition offsets by specification (earliest, latest, max_timestamp, or by timestamp) without requiring a consumer group (#613).
 - [Enhancement] Use native ARM64 runners instead of QEMU emulation for Alpine musl aarch64 builds, improving build performance and reliability.
 - [Enhancement] Enable parallel compilation (`make -j$(nproc)`) for ARM64 Alpine musl builds.
-- [Enhancement] Add file descriptor API for fiber scheduler integration. Expose `enable_queue_io_events` and `enable_background_queue_io_events` on `Consumer`, `Producer`, and `Admin` to enable non-blocking monitoring with select/poll/epoll for integration with Ruby fiber schedulers (Falcon, Async) and custom event loops.
+- [Enhancement] Add `enable_queue_io_events` and `enable_background_queue_io_events` to `Consumer`, `Producer` and `Admin` for non-blocking file descriptor monitoring with fiber schedulers (Falcon, Async) and custom event loops.
 - [Enhancement] Add non-blocking poll methods (`poll_nb`, `events_poll_nb`) on `Consumer` that skip GVL release for efficient fiber scheduler integration when using `poll(0)`.
 - [Enhancement] Add `events_poll_nb_each` method on `Producer`, `Consumer`, and `Admin` for polling events in a single GVL/mutex session. Yields count after each iteration, caller returns `:stop` to break.
 - [Enhancement] Add `poll_nb_each` method on `Consumer` for non-blocking message polling with proper resource cleanup, yielding each message and supporting early termination via `:stop` return value.

data/README.md

@@ -163,6 +163,7 @@ bundle exec rake produce_messages
 
 | rdkafka-ruby | librdkafka | patches |
 |-|-|-|
+| 0.31.x (2026-10-09) | 2.15.1 (2026-09-09) | yes |
 | 0.30.x (2026-09-25) | 2.15.0 (2026-06-30) | yes |
 | 0.29.x (2026-07-10) | 2.14.2 (2026-06-03) | yes |
 | 0.28.x (2026-06-03) | 2.14.1 (2026-04-15) | yes |

data/docker-compose-ssl.yml

@@ -17,6 +17,7 @@ services:
       KAFKA_LISTENER_SECURITY_PROTOCOL_MAP: CONTROLLER:PLAINTEXT,PLAINTEXT:PLAINTEXT,SSL:SSL
       KAFKA_ADVERTISED_LISTENERS: PLAINTEXT://127.0.0.1:9092,SSL://127.0.0.1:9093
       KAFKA_BROKER_ID: 1
+      KAFKA_BROKER_RACK: rack-1
       KAFKA_CONTROLLER_QUORUM_VOTERS: 1@127.0.0.1:9094
       ALLOW_PLAINTEXT_LISTENER: 'yes'
       KAFKA_AUTO_CREATE_TOPICS_ENABLE: 'false'

data/docker-compose.yml

@@ -16,6 +16,7 @@ services:
       KAFKA_LISTENER_SECURITY_PROTOCOL_MAP: CONTROLLER:PLAINTEXT,PLAINTEXT:PLAINTEXT
       KAFKA_ADVERTISED_LISTENERS: PLAINTEXT://127.0.0.1:9092
       KAFKA_BROKER_ID: 1
+      KAFKA_BROKER_RACK: rack-1
       KAFKA_CONTROLLER_QUORUM_VOTERS: 1@127.0.0.1:9093
       ALLOW_PLAINTEXT_LISTENER: 'yes'
       KAFKA_AUTO_CREATE_TOPICS_ENABLE: 'false'

data/lib/rdkafka/admin/describe_cluster_handle.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+module Rdkafka
+  class Admin
+    # Handle for describe cluster operation
+    class DescribeClusterHandle < AbstractHandle
+      layout :pending, :bool,
+        :response, :int
+
+      # @return [String] the name of the operation
+      def operation_name
+        "describe cluster"
+      end
+
+      # @return [DescribeClusterReport] report prepared by the background event callback, with
+      #   the cluster id, controller and broker nodes.
+      def create_result
+        prepared_result
+      end
+
+      # Raises an error if the operation failed
+      # @raise [RdkafkaError]
+      def raise_error
+        raise RdkafkaError.new(
+          self[:response],
+          broker_message: broker_message
+        )
+      end
+    end
+  end
+end

data/lib/rdkafka/admin/describe_cluster_report.rb

@@ -0,0 +1,48 @@
+# frozen_string_literal: true
+
+module Rdkafka
+  class Admin
+    # Report for describe cluster operation result
+    class DescribeClusterReport
+      include DescribeResultParsing
+
+      # @return [String, nil] the cluster id
+      attr_reader :cluster_id
+
+      # The current controller node, as a hash with `:id` [Integer], `:host` [String],
+      # `:port` [Integer] and `:rack` [String, nil]
+      # @return [Hash, nil]
+      attr_reader :controller
+
+      # Broker nodes of the cluster, each in the same shape as {#controller}
+      # @return [Array<Hash>]
+      attr_reader :nodes
+
+      # Operations the client is authorized to perform on the cluster, as
+      # `Bindings::RD_KAFKA_ACL_OPERATION_*` codes. `nil` unless requested with
+      # `include_authorized_operations: true`.
+      # @return [Array<Integer>, nil]
+      attr_reader :authorized_operations
+
+      # @param result_ptr [FFI::Pointer] pointer to the `rd_kafka_DescribeCluster_result_t`
+      def initialize(result_ptr)
+        @nodes = []
+
+        return if result_ptr.null?
+
+        cluster_id_ptr = Bindings.rd_kafka_DescribeCluster_result_cluster_id(result_ptr)
+        @cluster_id = cluster_id_ptr.null? ? nil : cluster_id_ptr.read_string
+        @controller = extract_node(Bindings.rd_kafka_DescribeCluster_result_controller(result_ptr))
+
+        count_ptr = FFI::MemoryPointer.new(:size_t)
+        @nodes = extract_nodes(Bindings.rd_kafka_DescribeCluster_result_nodes(result_ptr, count_ptr), count_ptr)
+
+        count_ptr = FFI::MemoryPointer.new(:size_t)
+        @authorized_operations = extract_authorized_operations(
+          Bindings.rd_kafka_DescribeCluster_result_authorized_operations(result_ptr, count_ptr),
+          count_ptr
+        )
+      end
+    end
+  end
+end

data/lib/rdkafka/admin/describe_consumer_groups_handle.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+module Rdkafka
+  class Admin
+    # Handle for describe consumer groups operation
+    class DescribeConsumerGroupsHandle < AbstractHandle
+      layout :pending, :bool,
+        :response, :int
+
+      # @return [String] the name of the operation
+      def operation_name
+        "describe consumer groups"
+      end
+
+      # @return [DescribeConsumerGroupsReport] report prepared by the background event callback,
+      #   with the described consumer groups.
+      def create_result
+        prepared_result
+      end
+
+      # Raises an error if the operation failed
+      # @raise [RdkafkaError]
+      def raise_error
+        raise RdkafkaError.new(
+          self[:response],
+          broker_message: broker_message
+        )
+      end
+    end
+  end
+end

data/lib/rdkafka/admin/describe_consumer_groups_report.rb

@@ -0,0 +1,151 @@
+# frozen_string_literal: true
+
+module Rdkafka
+  class Admin
+    # Report for describe consumer groups operation result
+    class DescribeConsumerGroupsReport
+      include DescribeResultParsing
+
+      # Described consumer groups, one per requested group id. Each entry is a hash with:
+      #   - `:group_id` [String] the consumer group id
+      #   - `:error` [RdkafkaError, nil] error describing this group, or `nil` on success. The
+      #     other fields are not meaningful when it is set.
+      #   - `:is_simple_consumer_group` [Boolean] `true` for a group that assigns partitions
+      #     manually and uses Kafka only for offset storage
+      #   - `:state` [Integer] the group state as a `Bindings::RD_KAFKA_CONSUMER_GROUP_STATE_*`
+      #     code. A group id the cluster does not know is reported as
+      #     `RD_KAFKA_CONSUMER_GROUP_STATE_DEAD` with no members.
+      #   - `:state_name` [String] human-readable name of that state (e.g. `"Stable"`, `"Empty"`)
+      #   - `:type` [Integer] the group protocol type as a
+      #     `Bindings::RD_KAFKA_CONSUMER_GROUP_TYPE_*` code, one of:
+      #     `RD_KAFKA_CONSUMER_GROUP_TYPE_CLASSIC`,
+      #     `RD_KAFKA_CONSUMER_GROUP_TYPE_CONSUMER` (KIP-848),
+      #     `RD_KAFKA_CONSUMER_GROUP_TYPE_UNKNOWN`
+      #   - `:type_name` [String] human-readable name of that type (e.g. `"Classic"`, `"Consumer"`)
+      #   - `:partition_assignor` [String, nil] partition assignor in use (e.g. `"range"`)
+      #   - `:coordinator` [Hash, nil] the group coordinator broker as
+      #     `{ id:, host:, port:, rack: }`
+      #   - `:authorized_operations` [Array<Integer>, nil] ACL operations the client may perform on
+      #     the group, as `Bindings::RD_KAFKA_ACL_OPERATION_*` codes. `nil` unless requested with
+      #     `include_authorized_operations: true`.
+      #   - `:members` [Array<Hash>] current group members, each with:
+      #     - `:member_id` [String] the member (consumer) id
+      #     - `:client_id` [String] the member's `client.id`
+      #     - `:group_instance_id` [String, nil] the static membership instance id, if any
+      #     - `:host` [String] the host the member connects from
+      #     - `:assignment` [Hash{String => Array<Integer>}] assigned partitions, by topic
+      #     - `:target_assignment` [Hash{String => Array<Integer>}, nil] partitions the member is
+      #       moving to during a rebalance, by topic. Only `consumer` (KIP-848) groups have it;
+      #       `nil` for `classic` groups.
+      # @return [Array<Hash>]
+      attr_reader :groups
+
+      # @param result_ptr [FFI::Pointer] pointer to the `rd_kafka_DescribeConsumerGroups_result_t`
+      def initialize(result_ptr)
+        @groups = []
+
+        return if result_ptr.null?
+
+        count_ptr = FFI::MemoryPointer.new(:size_t)
+        array_ptr = Bindings.rd_kafka_DescribeConsumerGroups_result_groups(result_ptr, count_ptr)
+
+        return if array_ptr.null?
+
+        array_ptr.read_array_of_pointer(count_ptr.read(:size_t)).each do |group_ptr|
+          @groups << build_group(group_ptr)
+        end
+      end
+
+      private
+
+      # @param group_ptr [FFI::Pointer] pointer to the `rd_kafka_ConsumerGroupDescription_t`
+      # @return [Hash]
+      def build_group(group_ptr)
+        state = Bindings.rd_kafka_ConsumerGroupDescription_state(group_ptr)
+        type = Bindings.rd_kafka_ConsumerGroupDescription_type(group_ptr)
+
+        {
+          group_id: read_string(Bindings.rd_kafka_ConsumerGroupDescription_group_id(group_ptr)),
+          error: build_error(Bindings.rd_kafka_ConsumerGroupDescription_error(group_ptr)),
+          is_simple_consumer_group:
+            Bindings.rd_kafka_ConsumerGroupDescription_is_simple_consumer_group(group_ptr) != 0,
+          state: state,
+          state_name: read_string(Bindings.rd_kafka_consumer_group_state_name(state)),
+          type: type,
+          type_name: read_string(Bindings.rd_kafka_consumer_group_type_name(type)),
+          partition_assignor:
+            read_string(Bindings.rd_kafka_ConsumerGroupDescription_partition_assignor(group_ptr)),
+          coordinator: extract_node(Bindings.rd_kafka_ConsumerGroupDescription_coordinator(group_ptr)),
+          authorized_operations: build_authorized_operations(group_ptr),
+          members: Array.new(Bindings.rd_kafka_ConsumerGroupDescription_member_count(group_ptr)) do |index|
+            build_member(Bindings.rd_kafka_ConsumerGroupDescription_member(group_ptr, index))
+          end
+        }
+      end
+
+      # @param member_ptr [FFI::Pointer] pointer to the `rd_kafka_MemberDescription_t`
+      # @return [Hash]
+      def build_member(member_ptr)
+        {
+          member_id: read_string(Bindings.rd_kafka_MemberDescription_consumer_id(member_ptr)),
+          client_id: read_string(Bindings.rd_kafka_MemberDescription_client_id(member_ptr)),
+          group_instance_id: read_string(Bindings.rd_kafka_MemberDescription_group_instance_id(member_ptr)),
+          host: read_string(Bindings.rd_kafka_MemberDescription_host(member_ptr)),
+          assignment: build_assignment(Bindings.rd_kafka_MemberDescription_assignment(member_ptr)),
+          target_assignment: build_target_assignment(member_ptr)
+        }
+      end
+
+      # @param assignment_ptr [FFI::Pointer] pointer to the `rd_kafka_MemberAssignment_t`
+      # @return [Hash{String => Array<Integer>}]
+      def build_assignment(assignment_ptr)
+        return {} if assignment_ptr.null?
+
+        tpl_ptr = Bindings.rd_kafka_MemberAssignment_partitions(assignment_ptr)
+
+        return {} if tpl_ptr.null?
+
+        Consumer::TopicPartitionList
+          .from_native_tpl(tpl_ptr)
+          .to_h
+          .transform_values { |partitions| (partitions || []).map(&:partition) }
+      end
+
+      # @param member_ptr [FFI::Pointer] pointer to the `rd_kafka_MemberDescription_t`
+      # @return [Hash{String => Array<Integer>}, nil]
+      def build_target_assignment(member_ptr)
+        assignment_ptr = Bindings.rd_kafka_MemberDescription_target_assignment(member_ptr)
+
+        assignment_ptr.null? ? nil : build_assignment(assignment_ptr)
+      end
+
+      # @param group_ptr [FFI::Pointer] pointer to the `rd_kafka_ConsumerGroupDescription_t`
+      # @return [Array<Integer>, nil]
+      def build_authorized_operations(group_ptr)
+        count_ptr = FFI::MemoryPointer.new(:size_t)
+
+        extract_authorized_operations(
+          Bindings.rd_kafka_ConsumerGroupDescription_authorized_operations(group_ptr, count_ptr),
+          count_ptr
+        )
+      end
+
+      # @param error_ptr [FFI::Pointer] pointer to the `rd_kafka_error_t`
+      # @return [RdkafkaError, nil]
+      def build_error(error_ptr)
+        return nil if error_ptr.null?
+
+        RdkafkaError.new(
+          Bindings.rd_kafka_error_code(error_ptr),
+          broker_message: read_string(Bindings.rd_kafka_error_string(error_ptr))
+        )
+      end
+
+      # @param ptr [FFI::Pointer] pointer to a C string
+      # @return [String, nil]
+      def read_string(ptr)
+        ptr.null? ? nil : ptr.read_string
+      end
+    end
+  end
+end

data/lib/rdkafka/admin/describe_result_parsing.rb

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+module Rdkafka
+  class Admin
+    # Helpers shared by the describe-topics and describe-cluster reports to copy nodes and
+    # authorized operations out of event-owned memory.
+    # @private
+    module DescribeResultParsing
+      private
+
+      # @param node_ptr [FFI::Pointer] pointer to a `rd_kafka_Node_t`
+      # @return [Hash, nil] node with `:id`, `:host`, `:port` and `:rack` or nil when NULL
+      def extract_node(node_ptr)
+        return nil if node_ptr.null?
+
+        host_ptr = Bindings.rd_kafka_Node_host(node_ptr)
+        rack_ptr = Bindings.rd_kafka_Node_rack(node_ptr)
+
+        {
+          id: Bindings.rd_kafka_Node_id(node_ptr),
+          host: host_ptr.null? ? nil : host_ptr.read_string,
+          port: Bindings.rd_kafka_Node_port(node_ptr),
+          rack: rack_ptr.null? ? nil : rack_ptr.read_string
+        }
+      end
+
+      # @param array_ptr [FFI::Pointer] pointer to a `rd_kafka_Node_t*` array
+      # @param count_ptr [FFI::MemoryPointer] size_t holding the array length
+      # @return [Array<Hash>] nodes as returned by {#extract_node}
+      def extract_nodes(array_ptr, count_ptr)
+        return [] if array_ptr.null?
+
+        array_ptr.read_array_of_pointer(count_ptr.read(:size_t)).map { |node_ptr| extract_node(node_ptr) }
+      end
+
+      # @param array_ptr [FFI::Pointer] pointer to a `rd_kafka_AclOperation_t` array
+      # @param count_ptr [FFI::MemoryPointer] size_t holding the array length
+      # @return [Array<Integer>, nil] `Bindings::RD_KAFKA_ACL_OPERATION_*` codes or nil when the
+      #   authorized operations were not requested
+      def extract_authorized_operations(array_ptr, count_ptr)
+        return nil if array_ptr.null?
+
+        array_ptr.read_array_of_int(count_ptr.read(:size_t))
+      end
+    end
+  end
+end

data/lib/rdkafka/admin/describe_topics_handle.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+module Rdkafka
+  class Admin
+    # Handle for describe topics operation
+    class DescribeTopicsHandle < AbstractHandle
+      layout :pending, :bool,
+        :response, :int
+
+      # @return [String] the name of the operation
+      def operation_name
+        "describe topics"
+      end
+
+      # @return [DescribeTopicsReport] report prepared by the background event callback, with
+      #   the described topics.
+      def create_result
+        prepared_result
+      end
+
+      # Raises an error if the operation failed
+      # @raise [RdkafkaError]
+      def raise_error
+        raise RdkafkaError.new(
+          self[:response],
+          broker_message: broker_message
+        )
+      end
+    end
+  end
+end

data/lib/rdkafka/admin/describe_topics_report.rb

@@ -0,0 +1,118 @@
+# frozen_string_literal: true
+
+module Rdkafka
+  class Admin
+    # Report for describe topics operation result
+    class DescribeTopicsReport
+      include DescribeResultParsing
+
+      # Described topics, one per requested topic name. Each entry is a hash with:
+      #   - `:name` [String] the topic name
+      #   - `:topic_id` [String, nil] the topic id (KIP-516), base64 encoded, or `nil` when the
+      #     topic could not be described
+      #   - `:is_internal` [Boolean] whether the topic is internal (e.g. `__consumer_offsets`)
+      #   - `:partitions` [Array<Hash>] each with `:partition` [Integer], `:leader` [Hash, nil] and
+      #     `:replicas` / `:isr` [Array<Hash>]; nodes have `:id`, `:host`, `:port` and `:rack`
+      #   - `:authorized_operations` [Array<Integer>, nil] `Bindings::RD_KAFKA_ACL_OPERATION_*`
+      #     codes, `nil` unless requested with `include_authorized_operations: true`
+      #   - `:error` [RdkafkaError, nil] per-topic error (e.g. `unknown_topic_or_part`), `nil`
+      #     on success
+      # @return [Array<Hash>]
+      attr_reader :topics
+
+      # @param result_ptr [FFI::Pointer] pointer to the `rd_kafka_DescribeTopics_result_t`
+      def initialize(result_ptr)
+        @topics = []
+
+        return if result_ptr.null?
+
+        count_ptr = FFI::MemoryPointer.new(:size_t)
+        array_ptr = Bindings.rd_kafka_DescribeTopics_result_topics(result_ptr, count_ptr)
+
+        return if array_ptr.null?
+
+        array_ptr.read_array_of_pointer(count_ptr.read(:size_t)).each do |topic_ptr|
+          @topics << extract_topic(topic_ptr)
+        end
+      end
+
+      private
+
+      # @param topic_ptr [FFI::Pointer] pointer to a `rd_kafka_TopicDescription_t`
+      # @return [Hash]
+      def extract_topic(topic_ptr)
+        name_ptr = Bindings.rd_kafka_TopicDescription_name(topic_ptr)
+        operations_count_ptr = FFI::MemoryPointer.new(:size_t)
+
+        {
+          name: name_ptr.null? ? nil : name_ptr.read_string,
+          topic_id: extract_topic_id(topic_ptr),
+          is_internal: Bindings.rd_kafka_TopicDescription_is_internal(topic_ptr) != 0,
+          partitions: extract_partitions(topic_ptr),
+          authorized_operations: extract_authorized_operations(
+            Bindings.rd_kafka_TopicDescription_authorized_operations(topic_ptr, operations_count_ptr),
+            operations_count_ptr
+          ),
+          error: extract_error(topic_ptr)
+        }
+      end
+
+      # librdkafka reports the zero UUID for a topic it could not describe
+      # @param topic_ptr [FFI::Pointer] pointer to a `rd_kafka_TopicDescription_t`
+      # @return [String, nil]
+      def extract_topic_id(topic_ptr)
+        uuid_ptr = Bindings.rd_kafka_TopicDescription_topic_id(topic_ptr)
+
+        return nil if uuid_ptr.null?
+        return nil if Bindings.rd_kafka_Uuid_most_significant_bits(uuid_ptr).zero? &&
+          Bindings.rd_kafka_Uuid_least_significant_bits(uuid_ptr).zero?
+
+        string_ptr = Bindings.rd_kafka_Uuid_base64str(uuid_ptr)
+        string_ptr.null? ? nil : string_ptr.read_string
+      end
+
+      # @param topic_ptr [FFI::Pointer] pointer to a `rd_kafka_TopicDescription_t`
+      # @return [Array<Hash>]
+      def extract_partitions(topic_ptr)
+        count_ptr = FFI::MemoryPointer.new(:size_t)
+        array_ptr = Bindings.rd_kafka_TopicDescription_partitions(topic_ptr, count_ptr)
+
+        return [] if array_ptr.null?
+
+        array_ptr.read_array_of_pointer(count_ptr.read(:size_t)).map do |partition_ptr|
+          replicas_count_ptr = FFI::MemoryPointer.new(:size_t)
+          isr_count_ptr = FFI::MemoryPointer.new(:size_t)
+
+          {
+            partition: Bindings.rd_kafka_TopicPartitionInfo_partition(partition_ptr),
+            leader: extract_node(Bindings.rd_kafka_TopicPartitionInfo_leader(partition_ptr)),
+            replicas: extract_nodes(
+              Bindings.rd_kafka_TopicPartitionInfo_replicas(partition_ptr, replicas_count_ptr),
+              replicas_count_ptr
+            ),
+            isr: extract_nodes(
+              Bindings.rd_kafka_TopicPartitionInfo_isr(partition_ptr, isr_count_ptr),
+              isr_count_ptr
+            )
+          }
+        end
+      end
+
+      # The error is owned by the result, so it is copied and not destroyed here.
+      # @param topic_ptr [FFI::Pointer] pointer to a `rd_kafka_TopicDescription_t`
+      # @return [RdkafkaError, nil]
+      def extract_error(topic_ptr)
+        error_ptr = Bindings.rd_kafka_TopicDescription_error(topic_ptr)
+
+        return nil if error_ptr.null?
+
+        code = Bindings.rd_kafka_error_code(error_ptr)
+
+        return nil if code == Bindings::RD_KAFKA_RESP_ERR_NO_ERROR
+
+        string_ptr = Bindings.rd_kafka_error_string(error_ptr)
+        RdkafkaError.new(code, broker_message: string_ptr.null? ? nil : string_ptr.read_string)
+      end
+    end
+  end
+end