karafka-rdkafka 0.20.0.rc3-x86_64-linux-gnu

data/.ruby-gemset

@@ -0,0 +1 @@
+rdkafka-ruby

data/.ruby-version

@@ -0,0 +1 @@
+3.4.4

data/.yardopts

@@ -0,0 +1,2 @@
+--no-private
+--markup=markdown

data/CHANGELOG.md

@@ -0,0 +1,323 @@
+# Rdkafka Changelog
+
+## 0.20.0 (Unreleased)
+- **[Feature]** Add precompiled `x86_64-linux-gnu` setup.
+- **[Feature]** Add precompiled `macos_arm64` setup.
+
+## 0.19.5 (2025-05-30)
+- [Enhancement] Allow for producing to non-existing topics with `key` and `partition_key` present.
+
+## 0.19.4 (2025-05-23)
+- [Change] Move to trusted-publishers and remove signing since no longer needed.
+
+## 0.19.3 (2025-05-23)
+- [Enhancement] Include broker message in the error full message if provided.
+
+## 0.19.2 (2025-05-20)
+- [Enhancement] Replace TTL-based partition count cache with a global cache that reuses `librdkafka` statistics data when possible.
+- [Enhancement] Roll out experimental jruby support.
+- [Fix] Fix issue where post-closed producer C topics refs would not be cleaned.
+- [Fix] Fiber causes Segmentation Fault.
+- [Change] Move to trusted-publishers and remove signing since no longer needed.
+
+## 0.19.1 (2025-04-07)
+- [Enhancement] Support producing and consuming of headers with mulitple values (KIP-82).
+- [Enhancement] Allow native Kafka customization poll time.
+
+## 0.19.0 (2025-01-20)
+- **[Breaking]** Deprecate and remove `#each_batch` due to data consistency concerns.
+- [Enhancement] Bump librdkafka to 2.8.0
+- [Fix] Restore `Rdkafka::Bindings.rd_kafka_global_init` as it was not the source of the original issue.
+
+## 0.18.1 (2024-12-04)
+- [Fix] Do not run `Rdkafka::Bindings.rd_kafka_global_init` on require to prevent some of macos versions from hanging on Puma fork.
+
+## 0.18.0 (2024-11-26)
+- **[Breaking]** Drop Ruby 3.0 support
+- [Enhancement] Bump librdkafka to 2.6.1
+- [Enhancement] Use default oauth callback if none is passed (bachmanity1)
+- [Enhancement] Expose `rd_kafka_global_init` to mitigate macos forking issues.
+- [Patch] Retire no longer needed cooperative-sticky patch.
+
+## 0.17.6 (2024-09-03)
+- [Fix] Fix incorrectly behaving CI on failures. 
+- [Fix] Fix invalid patches librdkafka references.
+
+## 0.17.5 (2024-09-03)
+- [Patch] Patch with "Add forward declaration to fix compilation without ssl" fix
+
+## 0.17.4 (2024-09-02)
+- [Enhancement] Bump librdkafka to 2.5.3
+- [Enhancement] Do not release GVL on `rd_kafka_name` (ferrous26)
+- [Fix] Fix unused variable reference in producer (lucasmvnascimento)
+
+## 0.17.3 (2024-08-09)
+- [Fix] Mitigate a case where FFI would not restart the background events callback dispatcher in forks.
+
+## 0.17.2 (2024-08-07)
+- [Enhancement] Support returning `#details` for errors that do have topic/partition related extra info.
+
+## 0.17.1 (2024-08-01)
+- [Enhancement] Support ability to release patches to librdkafka.
+- [Patch] Patch cooperative-sticky assignments in librdkafka.
+
+## 0.17.0 (2024-07-21)
+- [Enhancement] Bump librdkafka to 2.5.0
+
+## 0.16.1 (2024-07-10)
+- [Feature] Add `#seek_by` to be able to seek for a message by topic, partition and offset (zinahia)
+- [Change] Remove old producer timeout API warnings.
+- [Fix] Switch to local release of librdkafka to mitigate its unavailability.
+
+## 0.16.0 (2024-06-17)
+- **[Breaking]** Messages without headers returned by `#poll` contain frozen empty hash.
+- **[Breaking]** `HashWithSymbolKeysTreatedLikeStrings` has been removed so headers are regular hashes with string keys.
+- [Enhancement] Bump librdkafka to 2.4.0
+- [Enhancement] Save two objects on message produced and lower CPU usage on message produced with small improvements.
+- [Fix] Remove support for Ruby 2.7. Supporting it was a bug since rest of the karafka ecosystem no longer supports it.
+
+## 0.15.2 (2024-07-10)
+- [Fix] Switch to local release of librdkafka to mitigate its unavailability.
+
+## 0.15.1 (2024-05-09)
+- **[Feature]** Provide ability to use topic config on a producer for custom behaviors per dispatch.
+- [Enhancement] Use topic config reference cache for messages production to prevent topic objects allocation with each message.
+- [Enhancement] Provide `Rrdkafka::Admin#describe_errors` to get errors descriptions (mensfeld)
+
+## 0.15.0 (2024-04-26)
+- **[Feature]** Oauthbearer token refresh callback (bruce-szalwinski-he)
+- **[Feature]** Support incremental config describe + alter API (mensfeld)
+- [Enhancement] name polling Thread as `rdkafka.native_kafka#<name>` (nijikon)
+- [Enhancement] Replace time poll based wait engine with an event based to improve response times on blocking operations and wait (nijikon + mensfeld)
+- [Enhancement] Allow for usage of the second regex engine of librdkafka by setting `RDKAFKA_DISABLE_REGEX_EXT` during build (mensfeld)
+- [Enhancement] name polling Thread as `rdkafka.native_kafka#<name>` (nijikon)
+- [Change] Allow for native kafka thread operations deferring and manual start for consumer, producer and admin.
+- [Change] The `wait_timeout` argument in `AbstractHandle.wait` method is deprecated and will be removed in future versions without replacement. We don't rely on it's value anymore (nijikon)
+- [Fix] Fix bogus case/when syntax. Levels 1, 2, and 6 previously defaulted to UNKNOWN (jjowdy)
+
+## 0.14.11 (2024-07-10)
+- [Fix] Switch to local release of librdkafka to mitigate its unavailability.
+
+## 0.14.10 (2024-02-08)
+- [Fix] Background logger stops working after forking causing memory leaks (mensfeld).
+
+## 0.14.9 (2024-01-29)
+- [Fix] Partition cache caches invalid `nil` result for `PARTITIONS_COUNT_TTL`.
+- [Enhancement] Report `-1` instead of `nil` in case `partition_count` failure.
+
+## 0.14.8 (2024-01-24)
+- [Enhancement] Provide support for Nix OS (alexandriainfantino)
+- [Enhancement] Skip intermediate array creation on delivery report callback execution (one per message) (mensfeld)
+
+## 0.14.7 (2023-12-29)
+- [Fix] Recognize that Karafka uses a custom partition object (fixed in 2.3.0) and ensure it is recognized.
+
+## 0.14.6 (2023-12-29)
+- **[Feature]** Support storing metadata alongside offsets via `rd_kafka_offsets_store` in `#store_offset` (mensfeld)
+- [Enhancement] Increase the `#committed` default timeout from 1_200ms to 2000ms. This will compensate for network glitches and remote clusters operations and will align with metadata query timeout.
+
+## 0.14.5 (2023-12-20)
+- [Enhancement] Provide `label` producer handler and report reference for improved traceability.
+
+## 0.14.4 (2023-12-19)
+- [Enhancement] Add ability to store offsets in a transaction (mensfeld)
+
+## 0.14.3 (2023-12-17)
+- [Enhancement] Replace `rd_kafka_offset_store` with `rd_kafka_offsets_store` (mensfeld)
+- [Fix] Missing ACL `RD_KAFKA_RESOURCE_BROKER` constant reference (mensfeld)
+- [Change] Rename `matching_acl_pattern_type` to `matching_acl_resource_pattern_type` to align the whole API (mensfeld)
+
+## 0.14.2 (2023-12-11)
+- [Enhancement] Alias `topic_name` as `topic` in the delivery report (mensfeld)
+- [Fix] Fix return type on `#rd_kafka_poll` (mensfeld)
+- [Fix] `uint8_t` does not exist on Apple Silicon (mensfeld)
+
+## 0.14.1 (2023-12-02)
+- **[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)
+- **[Enhancement]** Improve error reporting on `unknown_topic_or_part` and include missing topic (mensfeld)
+- **[Enhancement]** Improve error reporting on consumer polling errors (mensfeld)
+
+## 0.14.0 (2023-11-17)
+- [Enhancement] Bump librdkafka to 2.3.0
+- [Enhancement] Increase the `#lag` and `#query_watermark_offsets` default timeouts from 100ms to 1000ms. This will compensate for network glitches and remote clusters operations.
+
+## 0.13.10 (2024-07-10)
+- [Fix] Switch to local release of librdkafka to mitigate its unavailability.
+
+## 0.13.9 (2023-11-07)
+- [Enhancement] Expose alternative way of managing consumer events via a separate queue.
+- [Enhancement] Allow for setting `statistics_callback` as nil to reset predefined settings configured by a different gem.
+
+## 0.13.8 (2023-10-31)
+- [Enhancement] Get consumer position (thijsc & mensfeld)
+
+## 0.13.7 (2023-10-31)
+- [Change] Drop support for Ruby 2.6 due to incompatibilities in usage of `ObjectSpace::WeakMap`
+- [Fix] Fix dangling Opaque references.
+
+## 0.13.6 (2023-10-17)
+- **[Feature]** Support transactions API in the producer
+- [Enhancement] Add `raise_response_error` flag to the `Rdkafka::AbstractHandle`.
+- [Enhancement] Provide `#purge` to remove any outstanding requests from the producer.
+- [Enhancement] Fix `#flush` does not handle the timeouts errors by making it return true if all flushed or false if failed. We do **not** raise an exception here to keep it backwards compatible.
+
+## 0.13.5
+- Fix DeliveryReport `create_result#error` being nil despite an error being associated with it
+
+## 0.13.4
+- Always call initial poll on librdkafka to make sure oauth bearer cb is handled pre-operations.
+
+## 0.13.3
+- Bump librdkafka to 2.2.0
+
+## 0.13.2
+- Ensure operations counter decrement is fully thread-safe
+- Bump librdkafka to 2.1.1
+
+## 0.13.1
+- Add offsets_for_times method on consumer (timflapper)
+
+## 0.13.0 (2023-07-24)
+- Support cooperative sticky partition assignment in the rebalance callback (methodmissing)
+- Support both string and symbol header keys (ColinDKelley)
+- Handle tombstone messages properly (kgalieva)
+- Add topic name to delivery report (maeve)
+- Allow string partitioner config (mollyegibson)
+- Fix documented type for DeliveryReport#error (jimmydo)
+- Bump librdkafka to 2.0.2 (lmaia)
+- Use finalizers to cleanly exit producer and admin (thijsc)
+- Lock access to the native kafka client (thijsc)
+- Fix potential race condition in multi-threaded producer (mensfeld)
+- Fix leaking FFI resources in specs (mensfeld)
+- Improve specs stability (mensfeld)
+- Make metadata request timeout configurable (mensfeld)
+- call_on_partitions_assigned and call_on_partitions_revoked only get a tpl passed in (thijsc)
+- Support `#assignment_lost?` on a consumer to check for involuntary assignment revocation (mensfeld)
+- Expose `#name` on the consumer and producer (mensfeld)
+- Introduce producer partitions count metadata cache (mensfeld)
+- Retry metadta fetches on certain errors with a backoff (mensfeld)
+- Do not lock access to underlying native kafka client and rely on Karafka granular locking (mensfeld)
+
+## 0.12.4 (2024-07-10)
+- [Fix] Switch to local release of librdkafka to mitigate its unavailability.
+
+## 0.12.3
+- Include backtrace in non-raised binded errors.
+- Include topic name in the delivery reports
+
+## 0.12.2
+- Increase the metadata default timeout from 250ms to 2 seconds. This should allow for working with remote clusters.
+
+## 0.12.1
+- Bumps librdkafka to 2.0.2 (lmaia)
+- Add support for adding more partitions via Admin API
+
+## 0.12.0 (2022-06-17)
+- Bumps librdkafka to 1.9.0
+- Fix crash on empty partition key (mensfeld)
+- Pass the delivery handle to the callback (gvisokinskas)
+
+## 0.11.0 (2021-11-17)
+- Upgrade librdkafka to 1.8.2
+- Bump supported minimum Ruby version to 2.6
+- Better homebrew path detection
+
+## 0.10.0 (2021-09-07)
+- Upgrade librdkafka to 1.5.0
+- Add error callback config
+
+## 0.9.0 (2021-06-23)
+- Fixes for Ruby 3.0
+- Allow any callable object for callbacks (gremerritt)
+- Reduce memory allocations in Rdkafka::Producer#produce (jturkel)
+- Use queue as log callback to avoid unsafe calls from trap context (breunigs)
+- Allow passing in topic configuration on create_topic (dezka)
+- Add each_batch method to consumer (mgrosso)
+
+## 0.8.1 (2020-12-07)
+- Fix topic_flag behaviour and add tests for Metadata (geoff2k)
+- Add topic admin interface (geoff2k)
+- Raise an exception if @native_kafka is nil (geoff2k)
+- Option to use zstd compression (jasonmartens)
+
+## 0.8.0 (2020-06-02)
+- Upgrade librdkafka to 1.4.0
+- Integrate librdkafka metadata API and add partition_key (by Adithya-copart)
+- Ruby 2.7 compatibility fix (by Geoff Thé)A
+- Add error to delivery report (by Alex Stanovsky)
+- Don't override CPPFLAGS and LDFLAGS if already set on Mac (by Hiroshi Hatake)
+- Allow use of Rake 13.x and up (by Tomasz Pajor)
+
+## 0.7.0 (2019-09-21)
+- Bump librdkafka to 1.2.0 (by rob-as)
+- Allow customizing the wait time for delivery report availability (by mensfeld)
+
+## 0.6.0 (2019-07-23)
+- Bump librdkafka to 1.1.0 (by Chris Gaffney)
+- Implement seek (by breunigs)
+
+## 0.5.0 (2019-04-11)
+- Bump librdkafka to 1.0.0 (by breunigs)
+- Add cluster and member information (by dmexe)
+- Support message headers for consumer & producer (by dmexe)
+- Add consumer rebalance listener (by dmexe)
+- Implement pause/resume partitions (by dmexe)
+
+## 0.4.2 (2019-01-12)
+- Delivery callback for producer
+- Document list param of commit method
+- Use default Homebrew openssl location if present
+- Consumer lag handles empty topics
+- End iteration in consumer when it is closed
+- Add support for storing message offsets
+- Add missing runtime dependency to rake
+
+## 0.4.1 (2018-10-19)
+- Bump librdkafka to 0.11.6
+
+## 0.4.0 (2018-09-24)
+- Improvements in librdkafka archive download
+- Add global statistics callback
+- Use Time for timestamps, potentially breaking change if you
+  rely on the previous behavior where it returns an integer with
+  the number of milliseconds.
+- Bump librdkafka to 0.11.5
+- Implement TopicPartitionList in Ruby so we don't have to keep
+  track of native objects.
+- Support committing a topic partition list
+- Add consumer assignment method
+
+## 0.3.5 (2018-01-17)
+- Fix crash when not waiting for delivery handles
+- Run specs on Ruby 2.5
+
+## 0.3.4 (2017-12-05)
+- Bump librdkafka to 0.11.3
+
+## 0.3.3 (2017-10-27)
+- Fix bug that prevent display of `RdkafkaError` message
+
+## 0.3.2 (2017-10-25)
+- `add_topic` now supports using a partition count
+- Add way to make errors clearer with an extra message
+- Show topics in subscribe error message
+- Show partition and topic in query watermark offsets error message
+
+## 0.3.1 (2017-10-23)
+- Bump librdkafka to 0.11.1
+- Officially support ranges in `add_topic` for topic partition list.
+- Add consumer lag calculator
+
+## 0.3.0 (2017-10-17)
+- Move both add topic methods to one `add_topic` in `TopicPartitionList`
+- Add committed offsets to consumer
+- Add query watermark offset to consumer
+
+## 0.2.0 (2017-10-13)
+- Some refactoring and add inline documentation
+
+## 0.1.x (2017-09-10)
+- Initial working version including producing and consuming

data/Gemfile

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+source "https://rubygems.org"
+
+gemspec

data/MIT-LICENSE

@@ -0,0 +1,22 @@
+The MIT License (MIT)
+
+Copyright (c) 2017-2023 Thijs Cadier
+              2023, Maciej Mensfeld
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

data/README.md

@@ -0,0 +1,177 @@
+# Rdkafka
+
+[![Build Status](https://github.com/karafka/rdkafka-ruby/actions/workflows/ci.yml/badge.svg)](https://github.com/karafka/rdkafka-ruby/actions/workflows/ci.yml)
+[![Gem Version](https://badge.fury.io/rb/rdkafka.svg)](https://badge.fury.io/rb/rdkafka)
+[![Join the chat at https://slack.karafka.io](https://raw.githubusercontent.com/karafka/misc/master/slack.svg)](https://slack.karafka.io)
+
+> [!NOTE]
+> The `rdkafka-ruby` gem was created and developed by [AppSignal](https://www.appsignal.com/). Their impactful contributions have significantly shaped the Ruby Kafka and Karafka ecosystems. For robust monitoring, we highly recommend AppSignal.
+
+---
+
+The `rdkafka` gem is a modern Kafka client library for Ruby based on
+[librdkafka](https://github.com/confluentinc/librdkafka/).
+It wraps the production-ready C client using the [ffi](https://github.com/ffi/ffi)
+gem and targets Kafka 1.0+ and Ruby versions under security or
+active maintenance. We remove a Ruby version from our CI builds when they 
+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 essential 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)
+- [Forking](#forking)
+- [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
+
+When installed, this gem downloads and compiles librdkafka. If you have any problems installing the gem, please open an issue.
+
+## Usage
+
+Please see the [documentation](https://karafka.io/docs/code/rdkafka-ruby/) for full details on how to use this gem. Below are two quick examples.
+
+Unless you are seeking specific low-level capabilities, we **strongly** recommend using [Karafka](https://github.com/karafka/karafka) and [WaterDrop](https://github.com/karafka/waterdrop) when working with Kafka. These are higher-level libraries also maintained by us based on rdkafka-ruby.
+
+### Consuming Messages
+
+Subscribe to a topic and get messages. Kafka will automatically spread
+the available partitions over consumers with the same group id.
+
+```ruby
+config = {
+  :"bootstrap.servers" => "localhost:9092",
+  :"group.id" => "ruby-test"
+}
+consumer = Rdkafka::Config.new(config).consumer
+consumer.subscribe("ruby-test-topic")
+
+consumer.each do |message|
+  puts "Message received: #{message}"
+end
+```
+
+### Producing Messages
+
+Produce several messages, put the delivery handles in an array, and
+wait for them before exiting. This way the messages will be batched and
+efficiently sent to Kafka.
+
+```ruby
+config = {:"bootstrap.servers" => "localhost:9092"}
+producer = Rdkafka::Config.new(config).producer
+delivery_handles = []
+
+100.times do |i|
+  puts "Producing message #{i}"
+  delivery_handles << producer.produce(
+      topic:   "ruby-test-topic",
+      payload: "Payload #{i}",
+      key:     "Key #{i}"
+  )
+end
+
+delivery_handles.each(&:wait)
+```
+
+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
+
+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
+
+* [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
+
+* [WaterDrop](https://github.com/karafka/waterdrop) – Standalone Karafka library for producing Kafka messages.
+
+## Forking
+
+When working with `rdkafka-ruby`, it's essential to know that the underlying `librdkafka` library does not support fork-safe operations, even though it is thread-safe. Forking a process after initializing librdkafka clients can lead to unpredictable behavior due to inherited file descriptors and memory states. This limitation requires careful handling, especially in Ruby applications that rely on forking.
+
+To address this, it's highly recommended to:
+
+- Never initialize any `rdkafka-ruby` producers or consumers before forking to avoid state corruption.
+- Before forking, always close any open producers or consumers if you've opened any.
+- Use high-level libraries like [WaterDrop](https://github.com/karafka/waterdrop) and [Karafka](https://github.com/karafka/karafka/), which provide abstractions for handling librdkafka's intricacies.
+
+## Development
+
+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`.
+
+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:
+
+```
+docker-compose down
+```
+
+## Example
+
+To see everything working, run these in separate tabs:
+
+```
+bundle exec rake consume_messages
+bundle exec rake produce_messages
+```
+
+## Versions
+
+| rdkafka-ruby | librdkafka | patches |
+|-|-|-|
+| 0.20.x (Unreleased) | 2.8.0 (2025-01-07)  | yes |
+| 0.19.x (2025-01-20) | 2.8.0 (2025-01-07)  | yes |
+| 0.18.0 (2024-11-26) | 2.6.1 (2024-11-18)  | yes |
+| 0.17.4 (2024-09-02) | 2.5.3 (2024-09-02)  | yes |
+| 0.17.0 (2024-08-01) | 2.5.0 (2024-07-10)  | yes |
+| 0.16.0 (2024-06-13) | 2.4.0 (2024-05-07)  | no  |
+| 0.15.0 (2023-12-03) | 2.3.0 (2023-10-25)  | no  |
+| 0.14.0 (2023-11-21) | 2.2.0 (2023-07-12)  | no  |
+| 0.13.0 (2023-07-24) | 2.0.2 (2023-01-20)  | no  |
+| 0.12.0 (2022-06-17) | 1.9.0 (2022-06-16)  | no  |
+| 0.11.0 (2021-11-17) | 1.8.2 (2021-10-18)  | no  |
+| 0.10.0 (2021-09-07) | 1.5.0 (2020-07-20)  | no  |

data/Rakefile

@@ -0,0 +1,96 @@
+# frozen_string_literal: true
+
+require 'bundler/gem_tasks'
+require "./lib/rdkafka"
+
+desc 'Generate some message traffic'
+task :produce_messages do
+  config = {:"bootstrap.servers" => "localhost:9092"}
+  if ENV["DEBUG"]
+    config[:debug] = "broker,topic,msg"
+  end
+  producer = Rdkafka::Config.new(config).producer
+
+  delivery_handles = []
+  100.times do |i|
+    puts "Producing message #{i}"
+    delivery_handles << producer.produce(
+        topic:   "rake_test_topic",
+        payload: "Payload #{i} from Rake",
+        key:     "Key #{i} from Rake"
+    )
+  end
+  puts 'Waiting for delivery'
+  delivery_handles.each(&:wait)
+  puts 'Done'
+end
+
+desc 'Consume some messages'
+task :consume_messages do
+  config = {
+    :"bootstrap.servers" => "localhost:9092",
+    :"group.id" => "rake_test",
+    :"enable.partition.eof" => false,
+    :"auto.offset.reset" => "earliest",
+    :"statistics.interval.ms" => 10_000
+  }
+  if ENV["DEBUG"]
+    config[:debug] = "cgrp,topic,fetch"
+  end
+  Rdkafka::Config.statistics_callback = lambda do |stats|
+    puts stats
+  end
+  consumer = Rdkafka::Config.new(config).consumer
+  consumer = Rdkafka::Config.new(config).consumer
+  consumer.subscribe("rake_test_topic")
+  consumer.each do |message|
+    puts "Message received: #{message}"
+  end
+end
+
+desc 'Hammer down'
+task :load_test do
+  puts "Starting load test"
+
+  config = Rdkafka::Config.new(
+    :"bootstrap.servers" => "localhost:9092",
+    :"group.id" => "load-test",
+    :"enable.partition.eof" => false
+  )
+
+  # Create a producer in a thread
+  Thread.new do
+    producer = config.producer
+    loop do
+      handles = []
+      1000.times do |i|
+        handles.push(producer.produce(
+          topic:   "load_test_topic",
+          payload: "Payload #{i}",
+          key:     "Key #{i}"
+        ))
+      end
+      handles.each(&:wait)
+      puts "Produced 1000 messages"
+    end
+  end.abort_on_exception = true
+
+  # Create three consumers in threads
+  3.times do |i|
+    Thread.new do
+      count = 0
+      consumer = config.consumer
+      consumer.subscribe("load_test_topic")
+      consumer.each do |message|
+        count += 1
+        if count % 1000 == 0
+          puts "Received 1000 messages in thread #{i}"
+        end
+      end
+    end.abort_on_exception = true
+  end
+
+  loop do
+    sleep 1
+  end
+end

data/docker-compose.yml

@@ -0,0 +1,25 @@
+services:
+  kafka:
+    container_name: kafka
+    image: confluentinc/cp-kafka:8.0.0
+
+    ports:
+      - 9092:9092
+
+    environment:
+      CLUSTER_ID: kafka-docker-cluster-1
+      KAFKA_INTER_BROKER_LISTENER_NAME: PLAINTEXT
+      KAFKA_OFFSETS_TOPIC_REPLICATION_FACTOR: 1
+      KAFKA_PROCESS_ROLES: broker,controller
+      KAFKA_CONTROLLER_LISTENER_NAMES: CONTROLLER
+      KAFKA_LISTENERS: PLAINTEXT://:9092,CONTROLLER://:9093
+      KAFKA_LISTENER_SECURITY_PROTOCOL_MAP: CONTROLLER:PLAINTEXT,PLAINTEXT:PLAINTEXT
+      KAFKA_ADVERTISED_LISTENERS: PLAINTEXT://127.0.0.1:9092
+      KAFKA_BROKER_ID: 1
+      KAFKA_CONTROLLER_QUORUM_VOTERS: 1@127.0.0.1:9093
+      ALLOW_PLAINTEXT_LISTENER: 'yes'
+      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/README.md

@@ -0,0 +1,19 @@
+# Ext
+
+This gem depends on the `librdkafka` C library. It is downloaded, stored in
+`dist/` directory, and checked into source control.
+
+To update the `librdkafka` version follow the following steps:
+
+* Go to https://github.com/confluentinc/librdkafka/releases to get the new
+  version number and asset checksum for `tar.gz`.
+* Change the version in `lib/rdkafka/version.rb`
+* Change the `sha256` in `lib/rdkafka/version.rb`
+* Run `bundle exec rake dist:download` in the `ext` directory to download the
+  new release and place it in the `dist/` for you
+* Run `bundle exec rake` in the `ext` directory to build the new version
+* Run `docker-compose pull` in the main gem directory to ensure the docker
+  images used by the tests and run `docker-compose up`
+* Finally, run `bundle exec rspec` in the main gem directory to execute
+  the test suite to detect any regressions that may have been introduced
+  by the update