karafka-rdkafka 0.23.0.beta1-aarch64-linux-gnu → 0.23.1-aarch64-linux-gnu

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 1a05ee0f1c84cb74133c7f845a100668d0520d8e158b8ddd84861c0a3c339fc8
-  data.tar.gz: a8e2167cf2c3e260a186a3926606fadf93d8d2dd34d12c600efebdd60550245c
+  metadata.gz: f2cba22565892e3f20d07ec6184aa511e72ec10bf9dbfa19c4efbda213239406
+  data.tar.gz: 1ffc792ec3e6b942f88142212c3fdd16ccaa8d15a4f416bc9f53b328086ad829
 SHA512:
-  metadata.gz: dba50e19735faee2f0149d1620a361ece26e4517a0cf3d4830f193a41d41e6df8254a7ad73b623b74ff3f6ee45e39f505199964ba07aaff706a70ed9a90a394a
-  data.tar.gz: ad4d95ee82869e46a9d2f92aeb55fd79e2758480d5d12032c7db01a2f97bf77bb70880e8a12ef2d416f84102812eaf4c741b8fdd05cd4a245bd823e3e71a6eec
+  metadata.gz: 4bb0992f055c2bc94f840de140b25d57beaf71671767b29a220b2445202db64c4f6f8f7891bb06483d91683ace3b63217279547984103239a51dc070e534d45b
+  data.tar.gz: 07c58780a1586cc31edfa88c94496e603defc3488f9ab206d87e4a0e971ac3aa1b12fb5ab03da9d1b2b353016ef07fd2b0b0e021366561583bbabed9d613ba5c

data/CHANGELOG.md

@@ -1,7 +1,22 @@
 # Rdkafka Changelog
 
-## 0.23.0 (Unreleased)
-- [Enhancement] Bump librdkafka to 2.12.0.
+## 0.23.1 (2025-11-14)
+- **[Feature]** Add integrated fatal error handling in `RdkafkaError.validate!` - automatically detects and handles fatal errors (-150) with single entrypoint API.
+- [Enhancement] Add optional `client_ptr` parameter to `validate!` for automatic fatal error remapping to actual underlying error codes.
+- [Enhancement] Update all Producer and Consumer `validate!` calls to provide `client_ptr` for comprehensive fatal error handling.
+- [Enhancement] Add `rd_kafka_fatal_error()` FFI binding to retrieve actual fatal error details.
+- [Enhancement] Add `rd_kafka_test_fatal_error()` FFI binding for testing fatal error scenarios.
+- [Enhancement] Add `RdkafkaError.build_fatal` class method for centralized fatal error construction.
+- [Enhancement] Add comprehensive tests for fatal error handling including unit tests and integration tests.
+- [Enhancement] Add `RD_KAFKA_PARTITION_UA` constant for unassigned partition (-1).
+- [Enhancement] Replace magic numbers with named constants: use `RD_KAFKA_RESP_ERR_NO_ERROR` instead of `0` for error code checks (18 instances) and `RD_KAFKA_PARTITION_UA` instead of `-1` for partition values (9 instances) across the codebase for better code clarity and maintainability.
+- [Enhancement] Add `Rdkafka::Testing` module for testing fatal error scenarios on both producers and consumers.
+- [Deprecated] `RdkafkaError.validate_fatal!` - use `validate!` with `client_ptr` parameter instead.
+
+## 0.23.0 (2025-11-01)
+- [Enhancement] Bump librdkafka to 2.12.1.
+- [Enhancement] Force lock FFI to 1.17.1 or higher to include critical bug fixes around GCC, write barriers, and thread restarts for forks.
+- [Fix] Fix for Core dump when providing extensions to oauthbearer_set_token (dssjoblom)
 
 ## 0.22.2 (2025-10-09)
 - [Fix] Fix Github Action Ruby reference preventing non-compiled releases.
@@ -11,7 +26,7 @@
 - [Enhancement] Optimize producer header processing with early returns and efficient array operations (69% faster for nil headers, 41% faster for empty headers, 12-32% faster when headers are present, with larger improvements for complex header scenarios).
 
 ## 0.22.0 (2025-09-26)
-- **[Breaking]** Drop support for Ruby 3.1 to move forward with the fiber scheduler work.
+- **[EOL]** Drop support for Ruby 3.1 to move forward with the fiber scheduler work.
 - [Enhancement] Bump librdkafka to 2.11.1.
 - [Enhancement] Improve sigstore attestation for precompiled releases.
 - [Fix] Fix incorrectly set default SSL certs dir.
@@ -71,7 +86,7 @@
 - [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
+- **[EOL]** 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.
@@ -112,7 +127,7 @@
 - **[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.
+- **[EOL]** 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.
@@ -193,7 +208,7 @@
 - [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`
+- **[EOL]** 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)
@@ -260,7 +275,7 @@
 
 ## 0.11.0 (2021-11-17)
 - Upgrade librdkafka to 1.8.2
-- Bump supported minimum Ruby version to 2.6
+- **[EOL]** Bump supported minimum Ruby version to 2.6
 - Better homebrew path detection
 
 ## 0.10.0 (2021-09-07)

data/README.md

@@ -63,7 +63,7 @@ Contributions should generally be made to the upstream [rdkafka-ruby repository]
 
 | rdkafka-ruby | librdkafka | patches |
 |-|-|-|
-| 0.23.x (Unreleased) | 2.12.0 (2025-10-09)  | yes |
+| 0.23.x (2025-11-01) | 2.12.1 (2025-10-16)  | yes |
 | 0.22.x (2025-09-26) | 2.11.1 (2025-08-18)  | yes |
 | 0.21.x (2025-08-18) | 2.11.0 (2025-07-03)  | yes |
 | 0.20.x (2025-07-17) | 2.8.0  (2025-01-07)  | yes |

data/karafka-rdkafka.gemspec

@@ -67,7 +67,7 @@ Gem::Specification.new do |gem|
     gem.extensions = %w(ext/Rakefile)
   end
 
-  gem.add_dependency 'ffi', '~> 1.15'
+  gem.add_dependency 'ffi', '~> 1.17.1'
   gem.add_dependency 'json', '> 2.0'
   gem.add_dependency 'logger'
   gem.add_dependency 'mini_portile2', '~> 2.6'

data/lib/rdkafka/abstract_handle.rb

@@ -77,7 +77,7 @@ module Rdkafka
                 "Waiting for #{operation_name} timed out after #{max_wait_timeout} seconds"
               )
             end
-          elsif self[:response] != 0 && raise_response_error
+          elsif self[:response] != Rdkafka::Bindings::RD_KAFKA_RESP_ERR_NO_ERROR && raise_response_error
             raise_error
           else
             return create_result

data/lib/rdkafka/admin.rb

@@ -149,7 +149,7 @@ module Rdkafka
       # Create and register the handle we will return to the caller
       create_topic_handle = CreateTopicHandle.new
       create_topic_handle[:pending] = true
-      create_topic_handle[:response] = -1
+      create_topic_handle[:response] = Rdkafka::Bindings::RD_KAFKA_PARTITION_UA
       CreateTopicHandle.register(create_topic_handle)
       admin_options_ptr = @native_kafka.with_inner do |inner|
         Rdkafka::Bindings.rd_kafka_AdminOptions_new(inner, Rdkafka::Bindings::RD_KAFKA_ADMIN_OP_CREATETOPICS)
@@ -202,7 +202,7 @@ module Rdkafka
       # Create and register the handle we will return to the caller
       delete_groups_handle = DeleteGroupsHandle.new
       delete_groups_handle[:pending] = true
-      delete_groups_handle[:response] = -1
+      delete_groups_handle[:response] = Rdkafka::Bindings::RD_KAFKA_PARTITION_UA
       DeleteGroupsHandle.register(delete_groups_handle)
       admin_options_ptr = @native_kafka.with_inner do |inner|
         Rdkafka::Bindings.rd_kafka_AdminOptions_new(inner, Rdkafka::Bindings::RD_KAFKA_ADMIN_OP_DELETETOPICS)
@@ -259,7 +259,7 @@ module Rdkafka
       # Create and register the handle we will return to the caller
       delete_topic_handle = DeleteTopicHandle.new
       delete_topic_handle[:pending] = true
-      delete_topic_handle[:response] = -1
+      delete_topic_handle[:response] = Rdkafka::Bindings::RD_KAFKA_PARTITION_UA
       DeleteTopicHandle.register(delete_topic_handle)
       admin_options_ptr = @native_kafka.with_inner do |inner|
         Rdkafka::Bindings.rd_kafka_AdminOptions_new(inner, Rdkafka::Bindings::RD_KAFKA_ADMIN_OP_DELETETOPICS)
@@ -327,7 +327,7 @@ module Rdkafka
         # Create and register the handle we will return to the caller
         create_partitions_handle = CreatePartitionsHandle.new
         create_partitions_handle[:pending] = true
-        create_partitions_handle[:response] = -1
+        create_partitions_handle[:response] = Rdkafka::Bindings::RD_KAFKA_PARTITION_UA
         CreatePartitionsHandle.register(create_partitions_handle)
         admin_options_ptr = Rdkafka::Bindings.rd_kafka_AdminOptions_new(inner, Rdkafka::Bindings::RD_KAFKA_ADMIN_OP_CREATEPARTITIONS)
         Rdkafka::Bindings.rd_kafka_AdminOptions_set_opaque(admin_options_ptr, create_partitions_handle.to_ptr)
@@ -427,7 +427,7 @@ module Rdkafka
       # Create and register the handle that we will return to the caller
       create_acl_handle = CreateAclHandle.new
       create_acl_handle[:pending] = true
-      create_acl_handle[:response] = -1
+      create_acl_handle[:response] = Rdkafka::Bindings::RD_KAFKA_PARTITION_UA
       CreateAclHandle.register(create_acl_handle)
 
       admin_options_ptr = @native_kafka.with_inner do |inner|
@@ -534,7 +534,7 @@ module Rdkafka
       # Create and register the handle that we will return to the caller
       delete_acl_handle = DeleteAclHandle.new
       delete_acl_handle[:pending] = true
-      delete_acl_handle[:response] = -1
+      delete_acl_handle[:response] = Rdkafka::Bindings::RD_KAFKA_PARTITION_UA
       DeleteAclHandle.register(delete_acl_handle)
 
       admin_options_ptr = @native_kafka.with_inner do |inner|
@@ -634,7 +634,7 @@ module Rdkafka
       # Create and register the handle that we will return to the caller
       describe_acl_handle = DescribeAclHandle.new
       describe_acl_handle[:pending] = true
-      describe_acl_handle[:response] = -1
+      describe_acl_handle[:response] = Rdkafka::Bindings::RD_KAFKA_PARTITION_UA
       DescribeAclHandle.register(describe_acl_handle)
 
       admin_options_ptr = @native_kafka.with_inner do |inner|
@@ -680,7 +680,7 @@ module Rdkafka
 
       handle = DescribeConfigsHandle.new
       handle[:pending] = true
-      handle[:response] = -1
+      handle[:response] = Rdkafka::Bindings::RD_KAFKA_PARTITION_UA
 
       queue_ptr = @native_kafka.with_inner do |inner|
         Rdkafka::Bindings.rd_kafka_queue_get_background(inner)
@@ -753,7 +753,7 @@ module Rdkafka
 
       handle = IncrementalAlterConfigsHandle.new
       handle[:pending] = true
-      handle[:response] = -1
+      handle[:response] = Rdkafka::Bindings::RD_KAFKA_PARTITION_UA
 
       queue_ptr = @native_kafka.with_inner do |inner|
         Rdkafka::Bindings.rd_kafka_queue_get_background(inner)

data/lib/rdkafka/bindings.rb

@@ -22,14 +22,55 @@ module Rdkafka
       end
     end
 
-    ffi_lib File.join(__dir__, "../../ext/librdkafka.#{lib_extension}")
+    # Wrap ffi_lib to provide better error messages for glibc compatibility issues
+    begin
+      ffi_lib File.join(__dir__, "../../ext/librdkafka.#{lib_extension}")
+    rescue LoadError => e
+      error_message = e.message
+
+      # Check if this is a glibc version mismatch error
+      if error_message =~ /GLIBC_[\d.]+['"` ]?\s*not found/i
+        glibc_version = error_message[/GLIBC_([\d.]+)/, 1] || 'unknown'
+
+        raise Rdkafka::LibraryLoadError, <<~ERROR_MSG.strip
+          Failed to load librdkafka due to glibc compatibility issue.
+
+          The precompiled librdkafka binary requires glibc version #{glibc_version} or higher,
+          but your system has an older version installed.
+
+          To resolve this issue, you have two options:
+
+          1. Upgrade your system to a supported platform (recommended)
+
+          2. Force compilation from source by reinstalling without the precompiled binary:
+             gem install rdkafka --platform=ruby
+
+             Or if using Bundler, add to your Gemfile:
+             gem 'rdkafka', force_ruby_platform: true
+
+          Original error: #{error_message}
+        ERROR_MSG
+      else
+        # Re-raise the original error if it's not a glibc issue
+        raise
+      end
+    end
 
     RD_KAFKA_RESP_ERR__ASSIGN_PARTITIONS = -175
     RD_KAFKA_RESP_ERR__REVOKE_PARTITIONS = -174
     RD_KAFKA_RESP_ERR__STATE = -172
     RD_KAFKA_RESP_ERR__NOENT = -156
+    RD_KAFKA_RESP_ERR__FATAL = -150
     RD_KAFKA_RESP_ERR_NO_ERROR = 0
 
+    # Buffer size for fatal error strings, matches librdkafka expectations
+    FATAL_ERROR_BUFFER_SIZE = 256
+
+    # Unassigned partition
+    RD_KAFKA_PARTITION_UA = -1
+    # String representation of unassigned partition (used in stats hash keys)
+    RD_KAFKA_PARTITION_UA_STR = RD_KAFKA_PARTITION_UA.to_s.freeze
+
     RD_KAFKA_OFFSET_END       = -1
     RD_KAFKA_OFFSET_BEGINNING = -2
     RD_KAFKA_OFFSET_STORED    = -1000
@@ -161,6 +202,8 @@ module Rdkafka
     attach_function :rd_kafka_error_txn_requires_abort, [:pointer], :int
     attach_function :rd_kafka_error_destroy, [:pointer], :void
     attach_function :rd_kafka_get_err_descs, [:pointer, :pointer], :void
+    attach_function :rd_kafka_fatal_error, [:pointer, :pointer, :int], :int
+    attach_function :rd_kafka_test_fatal_error, [:pointer, :int, :string], :int
 
     # Configuration
 
@@ -234,7 +277,7 @@ module Rdkafka
         # Since this cache is shared, having few consumers and/or producers in one process will
         # automatically improve the querying times even with low refresh times.
         (stats['topics'] || EMPTY_HASH).each do |topic_name, details|
-          partitions_count = details['partitions'].keys.reject { |k| k == '-1' }.size
+          partitions_count = details['partitions'].keys.reject { |k| k == RD_KAFKA_PARTITION_UA_STR }.size
 
           next unless partitions_count.positive?
 
@@ -245,14 +288,51 @@ module Rdkafka
       end
 
       # Return 0 so librdkafka frees the json string
-      0
+      RD_KAFKA_RESP_ERR_NO_ERROR
+    end
+
+    # Retrieves fatal error details from a kafka client handle.
+    # This is a helper method to extract fatal error information consistently
+    # 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
+    #
+    # @example
+    #   details = Rdkafka::Bindings.extract_fatal_error(client_ptr)
+    #   if details
+    #     puts "Fatal error #{details[:error_code]}: #{details[:error_string]}"
+    #   end
+    def self.extract_fatal_error(client_ptr)
+      error_buffer = FFI::MemoryPointer.new(:char, FATAL_ERROR_BUFFER_SIZE)
+
+      error_code = rd_kafka_fatal_error(client_ptr, error_buffer, FATAL_ERROR_BUFFER_SIZE)
+
+      return nil if error_code == RD_KAFKA_RESP_ERR_NO_ERROR
+
+      {
+        error_code: error_code,
+        error_string: error_buffer.read_string
+      }
     end
 
     ErrorCallback = FFI::Function.new(
       :void, [:pointer, :int, :string, :pointer]
-    ) do |_client_prr, err_code, reason, _opaque|
+    ) do |client_ptr, err_code, reason, _opaque|
       if Rdkafka::Config.error_callback
-        error = Rdkafka::RdkafkaError.build(err_code, broker_message: reason)
+        # Handle fatal errors according to librdkafka documentation:
+        # When ERR__FATAL is received, we must call rd_kafka_fatal_error()
+        # to get the actual underlying fatal error code and description.
+        if err_code == RD_KAFKA_RESP_ERR__FATAL
+          error = Rdkafka::RdkafkaError.build_fatal(
+            client_ptr,
+            fallback_error_code: err_code,
+            fallback_message: reason
+          )
+        else
+          error = Rdkafka::RdkafkaError.build(err_code, broker_message: reason)
+        end
+
         error.set_backtrace(caller)
         Rdkafka::Config.error_callback.call(error)
       end
@@ -404,7 +484,7 @@ module Rdkafka
 
     def self.partitioner(topic_ptr, str, partition_count, partitioner = "consistent_random")
       # Return RD_KAFKA_PARTITION_UA(unassigned partition) when partition count is nil/zero.
-      return -1 unless partition_count&.nonzero?
+      return RD_KAFKA_PARTITION_UA unless partition_count&.nonzero?
 
       str_ptr = str.empty? ? FFI::MemoryPointer::NULL : FFI::MemoryPointer.from_string(str)
       method_name = PARTITIONERS.fetch(partitioner) do

data/lib/rdkafka/callbacks.rb

@@ -28,7 +28,7 @@ module Rdkafka
         native_error = Rdkafka::Bindings.rd_kafka_group_result_error(group_result_pointer)
 
         if native_error.null?
-          @result_error = 0
+          @result_error = Rdkafka::Bindings::RD_KAFKA_RESP_ERR_NO_ERROR
           @error_string = FFI::Pointer::NULL
         else
           @result_error = native_error[:code]
@@ -76,7 +76,7 @@ module Rdkafka
         rd_kafka_error_pointer = Rdkafka::Bindings.rd_kafka_DeleteAcls_result_response_error(acl_result_pointer)
         @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 @result_error == 0
+        if @result_error == Rdkafka::Bindings::RD_KAFKA_RESP_ERR_NO_ERROR
            # Get the number of matching acls
            pointer_to_size_t = FFI::MemoryPointer.new(:int32)
            @matching_acls = Rdkafka::Bindings.rd_kafka_DeleteAcls_result_response_matching_acls(acl_result_pointer, pointer_to_size_t)
@@ -102,7 +102,7 @@ module Rdkafka
         @matching_acls=[]
         @result_error = Rdkafka::Bindings.rd_kafka_event_error(event_ptr)
         @error_string = Rdkafka::Bindings.rd_kafka_event_error_string(event_ptr)
-        if @result_error == 0
+        if @result_error == Rdkafka::Bindings::RD_KAFKA_RESP_ERR_NO_ERROR
           acl_describe_result = Rdkafka::Bindings.rd_kafka_event_DescribeAcls_result(event_ptr)
           # Get the number of matching acls
           pointer_to_size_t = FFI::MemoryPointer.new(:int32)
@@ -120,7 +120,7 @@ module Rdkafka
         @result_error = Rdkafka::Bindings.rd_kafka_event_error(event_ptr)
         @error_string = Rdkafka::Bindings.rd_kafka_event_error_string(event_ptr)
 
-        if @result_error == 0
+        if @result_error == Rdkafka::Bindings::RD_KAFKA_RESP_ERR_NO_ERROR
           configs_describe_result = Rdkafka::Bindings.rd_kafka_event_DescribeConfigs_result(event_ptr)
           # Get the number of matching acls
           pointer_to_size_t = FFI::MemoryPointer.new(:int32)
@@ -138,7 +138,7 @@ module Rdkafka
         @result_error = Rdkafka::Bindings.rd_kafka_event_error(event_ptr)
         @error_string = Rdkafka::Bindings.rd_kafka_event_error_string(event_ptr)
 
-        if @result_error == 0
+        if @result_error == Rdkafka::Bindings::RD_KAFKA_RESP_ERR_NO_ERROR
           incremental_alter_result = Rdkafka::Bindings.rd_kafka_event_IncrementalAlterConfigs_result(event_ptr)
           # Get the number of matching acls
           pointer_to_size_t = FFI::MemoryPointer.new(:int32)
@@ -202,7 +202,7 @@ module Rdkafka
           describe_configs_handle[:response_string] = describe_configs.error_string
           describe_configs_handle[:pending] = false
 
-          if describe_configs.result_error == 0
+          if describe_configs.result_error == Rdkafka::Bindings::RD_KAFKA_RESP_ERR_NO_ERROR
             describe_configs_handle[:config_entries] = describe_configs.results
             describe_configs_handle[:entry_count] = describe_configs.results_count
           end
@@ -220,7 +220,7 @@ module Rdkafka
           incremental_alter_handle[:response_string] = incremental_alter.error_string
           incremental_alter_handle[:pending] = false
 
-          if incremental_alter.result_error == 0
+          if incremental_alter.result_error == Rdkafka::Bindings::RD_KAFKA_RESP_ERR_NO_ERROR
             incremental_alter_handle[:config_entries] = incremental_alter.results
             incremental_alter_handle[:entry_count] = incremental_alter.results_count
           end
@@ -313,7 +313,7 @@ module Rdkafka
           delete_acl_handle[:response] = delete_acl_results[0].result_error
           delete_acl_handle[:response_string] = delete_acl_results[0].error_string
 
-          if delete_acl_results[0].result_error == 0
+          if delete_acl_results[0].result_error == Rdkafka::Bindings::RD_KAFKA_RESP_ERR_NO_ERROR
             delete_acl_handle[:matching_acls] = delete_acl_results[0].matching_acls
             delete_acl_handle[:matching_acls_count] = delete_acl_results[0].matching_acls_count
           end
@@ -330,7 +330,7 @@ module Rdkafka
           describe_acl_handle[:response] = describe_acl.result_error
           describe_acl_handle[:response_string] = describe_acl.error_string
 
-          if describe_acl.result_error == 0
+          if describe_acl.result_error == Rdkafka::Bindings::RD_KAFKA_RESP_ERR_NO_ERROR
             describe_acl_handle[:acls] = describe_acl.matching_acls
             describe_acl_handle[:acls_count] = describe_acl.matching_acls_count
           end

data/lib/rdkafka/consumer/partition.rb

@@ -33,7 +33,7 @@ module Rdkafka
       def to_s
         message = "<Partition #{partition}"
         message += " offset=#{offset}" if offset
-        message += " err=#{err}" if err != 0
+        message += " err=#{err}" if err != Rdkafka::Bindings::RD_KAFKA_RESP_ERR_NO_ERROR
         message += " metadata=#{metadata}" if metadata != nil
         message += ">"
         message

data/lib/rdkafka/consumer/topic_partition_list.rb

@@ -57,7 +57,7 @@ module Rdkafka
           if partitions.is_a? Integer
             partitions = (0..partitions - 1)
           end
-          @data[topic.to_s] = partitions.map { |p| Partition.new(p, nil, 0) }
+          @data[topic.to_s] = partitions.map { |p| Partition.new(p, nil, Rdkafka::Bindings::RD_KAFKA_RESP_ERR_NO_ERROR) }
         end
       end
 
@@ -109,7 +109,7 @@ module Rdkafka
         native_tpl[:cnt].times do |i|
           ptr = native_tpl[:elems] + (i * Rdkafka::Bindings::TopicPartition.size)
           elem = Rdkafka::Bindings::TopicPartition.new(ptr)
-          if elem[:partition] == -1
+          if elem[:partition] == Rdkafka::Bindings::RD_KAFKA_PARTITION_UA
             data[elem[:topic]] = nil
           else
             partitions = data[elem[:topic]] || []
@@ -178,7 +178,7 @@ module Rdkafka
             Rdkafka::Bindings.rd_kafka_topic_partition_list_add(
               tpl,
               topic,
-              -1
+              Rdkafka::Bindings::RD_KAFKA_PARTITION_UA
             )
           end
         end

data/lib/rdkafka/consumer.rb

@@ -67,15 +67,14 @@ module Rdkafka
       tpl = Rdkafka::Bindings.rd_kafka_topic_partition_list_new(topics.length)
 
       topics.each do |topic|
-        Rdkafka::Bindings.rd_kafka_topic_partition_list_add(tpl, topic, -1)
+        Rdkafka::Bindings.rd_kafka_topic_partition_list_add(tpl, topic, Rdkafka::Bindings::RD_KAFKA_PARTITION_UA)
       end
 
       # Subscribe to topic partition list and check this was successful
-      response = @native_kafka.with_inner do |inner|
-        Rdkafka::Bindings.rd_kafka_subscribe(inner, tpl)
+      @native_kafka.with_inner do |inner|
+        response = Rdkafka::Bindings.rd_kafka_subscribe(inner, tpl)
+        Rdkafka::RdkafkaError.validate!(response, "Error subscribing to '#{topics.join(', ')}'", client_ptr: inner)
       end
-
-      Rdkafka::RdkafkaError.validate!(response, "Error subscribing to '#{topics.join(', ')}'")
     ensure
       Rdkafka::Bindings.rd_kafka_topic_partition_list_destroy(tpl) unless tpl.nil?
     end
@@ -87,12 +86,11 @@ module Rdkafka
     def unsubscribe
       closed_consumer_check(__method__)
 
-      response = @native_kafka.with_inner do |inner|
-        Rdkafka::Bindings.rd_kafka_unsubscribe(inner)
+      @native_kafka.with_inner do |inner|
+        response = Rdkafka::Bindings.rd_kafka_unsubscribe(inner)
+        Rdkafka::RdkafkaError.validate!(response, client_ptr: inner)
       end
 
-      Rdkafka::RdkafkaError.validate!(response)
-
       nil
     end
 
@@ -115,7 +113,7 @@ module Rdkafka
           Rdkafka::Bindings.rd_kafka_pause_partitions(inner, tpl)
         end
 
-        if response != 0
+        if response != Rdkafka::Bindings::RD_KAFKA_RESP_ERR_NO_ERROR
           list = TopicPartitionList.from_native_tpl(tpl)
           raise Rdkafka::RdkafkaTopicPartitionListError.new(response, list, "Error pausing '#{list.to_h}'")
         end
@@ -139,12 +137,11 @@ module Rdkafka
       tpl = list.to_native_tpl
 
       begin
-        response = @native_kafka.with_inner do |inner|
-          Rdkafka::Bindings.rd_kafka_resume_partitions(inner, tpl)
+        @native_kafka.with_inner do |inner|
+          response = Rdkafka::Bindings.rd_kafka_resume_partitions(inner, tpl)
+          Rdkafka::RdkafkaError.validate!(response, "Error resume '#{list.to_h}'", client_ptr: inner)
         end
 
-        Rdkafka::RdkafkaError.validate!(response, "Error resume '#{list.to_h}'")
-
         nil
       ensure
         Rdkafka::Bindings.rd_kafka_topic_partition_list_destroy(tpl)
@@ -159,12 +156,11 @@ module Rdkafka
       closed_consumer_check(__method__)
 
       ptr = FFI::MemoryPointer.new(:pointer)
-      response = @native_kafka.with_inner do |inner|
-        Rdkafka::Bindings.rd_kafka_subscription(inner, ptr)
+      @native_kafka.with_inner do |inner|
+        response = Rdkafka::Bindings.rd_kafka_subscription(inner, ptr)
+        Rdkafka::RdkafkaError.validate!(response, client_ptr: inner)
       end
 
-      Rdkafka::RdkafkaError.validate!(response)
-
       native = ptr.read_pointer
 
       begin
@@ -188,11 +184,10 @@ module Rdkafka
       tpl = list.to_native_tpl
 
       begin
-        response = @native_kafka.with_inner do |inner|
-          Rdkafka::Bindings.rd_kafka_assign(inner, tpl)
+        @native_kafka.with_inner do |inner|
+          response = Rdkafka::Bindings.rd_kafka_assign(inner, tpl)
+          Rdkafka::RdkafkaError.validate!(response, "Error assigning '#{list.to_h}'", client_ptr: inner)
         end
-
-        Rdkafka::RdkafkaError.validate!(response, "Error assigning '#{list.to_h}'")
       ensure
         Rdkafka::Bindings.rd_kafka_topic_partition_list_destroy(tpl)
       end
@@ -206,12 +201,11 @@ module Rdkafka
       closed_consumer_check(__method__)
 
       ptr = FFI::MemoryPointer.new(:pointer)
-      response = @native_kafka.with_inner do |inner|
-        Rdkafka::Bindings.rd_kafka_assignment(inner, ptr)
+      @native_kafka.with_inner do |inner|
+        response = Rdkafka::Bindings.rd_kafka_assignment(inner, ptr)
+        Rdkafka::RdkafkaError.validate!(response, client_ptr: inner)
       end
 
-      Rdkafka::RdkafkaError.validate!(response)
-
       tpl = ptr.read_pointer
 
       if !tpl.null?
@@ -255,12 +249,11 @@ module Rdkafka
       tpl = list.to_native_tpl
 
       begin
-        response = @native_kafka.with_inner do |inner|
-          Rdkafka::Bindings.rd_kafka_committed(inner, tpl, timeout_ms)
+        @native_kafka.with_inner do |inner|
+          response = Rdkafka::Bindings.rd_kafka_committed(inner, tpl, timeout_ms)
+          Rdkafka::RdkafkaError.validate!(response, client_ptr: inner)
         end
 
-        Rdkafka::RdkafkaError.validate!(response)
-
         TopicPartitionList.from_native_tpl(tpl)
       ensure
         Rdkafka::Bindings.rd_kafka_topic_partition_list_destroy(tpl)
@@ -284,12 +277,11 @@ module Rdkafka
 
       tpl = list.to_native_tpl
 
-      response = @native_kafka.with_inner do |inner|
-        Rdkafka::Bindings.rd_kafka_position(inner, tpl)
+      @native_kafka.with_inner do |inner|
+        response = Rdkafka::Bindings.rd_kafka_position(inner, tpl)
+        Rdkafka::RdkafkaError.validate!(response, client_ptr: inner)
       end
 
-      Rdkafka::RdkafkaError.validate!(response)
-
       TopicPartitionList.from_native_tpl(tpl)
     end
 
@@ -306,8 +298,8 @@ module Rdkafka
       low = FFI::MemoryPointer.new(:int64, 1)
       high = FFI::MemoryPointer.new(:int64, 1)
 
-      response = @native_kafka.with_inner do |inner|
-        Rdkafka::Bindings.rd_kafka_query_watermark_offsets(
+      @native_kafka.with_inner do |inner|
+        response = Rdkafka::Bindings.rd_kafka_query_watermark_offsets(
           inner,
           topic,
           partition,
@@ -315,10 +307,9 @@ module Rdkafka
           high,
           timeout_ms,
         )
+        Rdkafka::RdkafkaError.validate!(response, "Error querying watermark offsets for partition #{partition} of #{topic}", client_ptr: inner)
       end
 
-      Rdkafka::RdkafkaError.validate!(response, "Error querying watermark offsets for partition #{partition} of #{topic}")
-
       return low.read_array_of_int64(1).first, high.read_array_of_int64(1).first
     ensure
       low.free   unless low.nil?
@@ -414,15 +405,14 @@ module Rdkafka
 
       tpl = list.to_native_tpl
 
-      response = @native_kafka.with_inner do |inner|
-        Rdkafka::Bindings.rd_kafka_offsets_store(
+      @native_kafka.with_inner do |inner|
+        response = Rdkafka::Bindings.rd_kafka_offsets_store(
           inner,
           tpl
         )
+        Rdkafka::RdkafkaError.validate!(response, client_ptr: inner)
       end
 
-      Rdkafka::RdkafkaError.validate!(response)
-
       nil
     ensure
       Rdkafka::Bindings.rd_kafka_topic_partition_list_destroy(tpl) if tpl
@@ -459,15 +449,19 @@ module Rdkafka
           nil
         )
       end
+
       response = Rdkafka::Bindings.rd_kafka_seek(
         native_topic,
         partition,
         offset,
         0 # timeout
       )
-      Rdkafka::RdkafkaError.validate!(response)
 
-      nil
+      return nil if response == Rdkafka::Bindings::RD_KAFKA_RESP_ERR_NO_ERROR
+
+      @native_kafka.with_inner do |inner|
+        Rdkafka::RdkafkaError.validate!(response, client_ptr: inner)
+      end
     ensure
       if native_topic && !native_topic.null?
         Rdkafka::Bindings.rd_kafka_topic_destroy(native_topic)
@@ -490,16 +484,15 @@ module Rdkafka
 
       tpl = list.to_native_tpl
 
-      response = @native_kafka.with_inner do |inner|
-        Rdkafka::Bindings.rd_kafka_offsets_for_times(
+      @native_kafka.with_inner do |inner|
+        response = Rdkafka::Bindings.rd_kafka_offsets_for_times(
           inner,
           tpl,
           timeout_ms # timeout
         )
+        Rdkafka::RdkafkaError.validate!(response, client_ptr: inner)
       end
 
-      Rdkafka::RdkafkaError.validate!(response)
-
       TopicPartitionList.from_native_tpl(tpl)
     ensure
       Rdkafka::Bindings.rd_kafka_topic_partition_list_destroy(tpl) if tpl
@@ -528,12 +521,11 @@ module Rdkafka
       tpl = list ? list.to_native_tpl : nil
 
       begin
-        response = @native_kafka.with_inner do |inner|
-          Rdkafka::Bindings.rd_kafka_commit(inner, tpl, async)
+        @native_kafka.with_inner do |inner|
+          response = Rdkafka::Bindings.rd_kafka_commit(inner, tpl, async)
+          Rdkafka::RdkafkaError.validate!(response, client_ptr: inner)
         end
 
-        Rdkafka::RdkafkaError.validate!(response)
-
         nil
       ensure
         Rdkafka::Bindings.rd_kafka_topic_partition_list_destroy(tpl) if tpl
@@ -558,10 +550,12 @@ module Rdkafka
       native_message = Rdkafka::Bindings::Message.new(message_ptr)
 
       # Create a message to pass out
-      return Rdkafka::Consumer::Message.new(native_message) if native_message[:err].zero?
+      return Rdkafka::Consumer::Message.new(native_message) if native_message[:err] == Rdkafka::Bindings::RD_KAFKA_RESP_ERR_NO_ERROR
 
-      # Raise error if needed
-      Rdkafka::RdkafkaError.validate!(native_message)
+      # Raise error if needed - wrap just the validate! call with client access
+      @native_kafka.with_inner do |inner|
+        Rdkafka::RdkafkaError.validate!(native_message, client_ptr: inner)
+      end
     ensure
       # Clean up rdkafka message if there is one
       if message_ptr && !message_ptr.null?

data/lib/rdkafka/error.rb

@@ -29,7 +29,7 @@ module Rdkafka
       def build_from_c(response_ptr, message_prefix = nil, broker_message: nil)
         code = Rdkafka::Bindings.rd_kafka_error_code(response_ptr)
 
-        return false if code.zero?
+        return false if code == Bindings::RD_KAFKA_RESP_ERR_NO_ERROR
 
         message = broker_message || Rdkafka::Bindings.rd_kafka_err2str(code)
         fatal = !Rdkafka::Bindings.rd_kafka_error_is_fatal(response_ptr).zero?
@@ -51,11 +51,11 @@ module Rdkafka
       def build(response_ptr_or_code, message_prefix = nil, broker_message: nil)
         case response_ptr_or_code
         when Integer
-          return false if response_ptr_or_code.zero?
+          return false if response_ptr_or_code == Bindings::RD_KAFKA_RESP_ERR_NO_ERROR
 
           new(response_ptr_or_code, message_prefix, broker_message: broker_message)
         when Bindings::Message
-          return false if response_ptr_or_code[:err].zero?
+          return false if response_ptr_or_code[:err] == Bindings::RD_KAFKA_RESP_ERR_NO_ERROR
 
           unless response_ptr_or_code[:payload].null?
             message_prefix ||= response_ptr_or_code[:payload].read_string(response_ptr_or_code[:len])
@@ -81,9 +81,49 @@ module Rdkafka
         end
       end
 
-      def validate!(response_ptr_or_code, message_prefix = nil, broker_message: nil)
+      def validate!(response_ptr_or_code, message_prefix = nil, broker_message: nil, client_ptr: nil)
         error = build(response_ptr_or_code, message_prefix, broker_message: broker_message)
-        error ? raise(error) : false
+
+        return false unless error
+
+        # Auto-detect and handle fatal errors (-150)
+        if error.rdkafka_response == Bindings::RD_KAFKA_RESP_ERR__FATAL && client_ptr
+          # Discover the underlying fatal error from librdkafka
+          error = build_fatal(
+            client_ptr,
+            fallback_error_code: error.rdkafka_response,
+            fallback_message: broker_message
+          )
+        end
+
+        raise error
+      end
+
+      # Build a fatal error from librdkafka's fatal error state.
+      # Calls rd_kafka_fatal_error() to get the actual underlying error code and description.
+      #
+      # @param client_ptr [FFI::Pointer] Pointer to rd_kafka_t client
+      # @param fallback_error_code [Integer] Error code to use if no fatal error found (default: -150)
+      # @param fallback_message [String, nil] Message to use if no fatal error found
+      # @return [RdkafkaError] Error object with fatal flag set to true
+      def build_fatal(client_ptr, fallback_error_code: -150, fallback_message: nil)
+        fatal_error_details = Rdkafka::Bindings.extract_fatal_error(client_ptr)
+
+        if fatal_error_details
+          new(
+            fatal_error_details[:error_code],
+            broker_message: fatal_error_details[:error_string],
+            fatal: true
+          )
+        else
+          # Fallback: if extract_fatal_error returns nil (shouldn't happen in practice),
+          # the error code itself still indicates a fatal condition
+          new(
+            fallback_error_code,
+            broker_message: fallback_message,
+            fatal: true
+          )
+        end
       end
     end
 
@@ -198,4 +238,7 @@ module Rdkafka
       super("Illegal call to a closed inner librdkafka instance")
     end
   end
+
+  # Error class for librdkafka library loading failures (e.g., glibc compatibility issues).
+  class LibraryLoadError < BaseError; end
 end

data/lib/rdkafka/helpers/oauth.rb

@@ -12,15 +12,21 @@ module Rdkafka
       # @return [Integer] 0 on success
       def oauthbearer_set_token(token:, lifetime_ms:, principal_name:, extensions: nil)
         error_buffer = FFI::MemoryPointer.from_string(" " * 256)
+        extensions_ptr, extensions_str_ptrs = map_extensions(extensions)
 
-        response = @native_kafka.with_inner do |inner|
-          Rdkafka::Bindings.rd_kafka_oauthbearer_set_token(
-            inner, token, lifetime_ms, principal_name,
-            flatten_extensions(extensions), extension_size(extensions), error_buffer, 256
-          )
+        begin
+          response = @native_kafka.with_inner do |inner|
+            Rdkafka::Bindings.rd_kafka_oauthbearer_set_token(
+              inner, token, lifetime_ms, principal_name,
+              extensions_ptr, extension_size(extensions), error_buffer, 256
+            )
+          end
+        ensure
+          extensions_str_ptrs&.each { |ptr| ptr.free }
+          extensions_ptr&.free
         end
 
-        return response if response.zero?
+        return response if response == Rdkafka::Bindings::RD_KAFKA_RESP_ERR_NO_ERROR
 
         oauthbearer_set_token_failure("Failed to set token: #{error_buffer.read_string}")
 
@@ -41,10 +47,31 @@ module Rdkafka
 
       private
 
-      # Flatten the extensions hash into a string according to the spec, https://datatracker.ietf.org/doc/html/rfc7628#section-3.1
-      def flatten_extensions(extensions)
-        return nil unless extensions
-        "\x01#{extensions.map { |e| e.join("=") }.join("\x01")}"
+      # Convert extensions hash to FFI::MemoryPointer (const char **).
+      # Note: the returned pointers must be freed manually (autorelease = false).
+      def map_extensions(extensions)
+        return [nil, nil] if extensions.nil? || extensions.empty?
+
+        # https://github.com/confluentinc/librdkafka/blob/master/src/rdkafka_sasl_oauthbearer.c#L327-L347
+
+        # The method argument is const char **
+        array_ptr = FFI::MemoryPointer.new(:pointer, extension_size(extensions))
+        array_ptr.autorelease = false
+        str_ptrs = []
+
+        # Element i is the key, i + 1 is the value.
+        extensions.each_with_index do |(k, v), i|
+          k_ptr = FFI::MemoryPointer.from_string(k.to_s)
+          k_ptr.autorelease = false
+          str_ptrs << k_ptr
+          v_ptr = FFI::MemoryPointer.from_string(v.to_s)
+          v_ptr.autorelease = false
+          str_ptrs << v_ptr
+          array_ptr[i * 2].put_pointer(0, k_ptr)
+          array_ptr[i * 2 + 1].put_pointer(0, v_ptr)
+        end
+
+        [array_ptr, str_ptrs]
       end
 
       # extension_size is the number of keys + values which should be a non-negative even number

data/lib/rdkafka/producer/delivery_handle.rb

@@ -25,7 +25,7 @@ module Rdkafka
 
       # @return [DeliveryReport] a report on the delivery of the message
       def create_result
-        if self[:response] == 0
+        if self[:response] == Rdkafka::Bindings::RD_KAFKA_RESP_ERR_NO_ERROR
           DeliveryReport.new(
             self[:partition],
             self[:offset],

data/lib/rdkafka/producer/testing.rb

@@ -0,0 +1,51 @@
+# frozen_string_literal: true
+
+module Rdkafka
+  # Testing utilities for Producer instances.
+  # This module is NOT included by default and should only be used in test environments.
+  #
+  # This module provides librdkafka native testing utilities that are needed to trigger certain
+  # behaviours that are hard to reproduce in stable environments, particularly fatal error
+  # scenarios in idempotent and transactional producers.
+  #
+  # To use in tests for producers:
+  #   producer.singleton_class.include(Rdkafka::Testing)
+  #
+  # Or include it for all producers in your test suite:
+  #   Rdkafka::Producer.include(Rdkafka::Testing)
+  #
+  # IMPORTANT: Fatal errors leave the producer client in an unusable state. After triggering
+  # a fatal error, the producer should be closed and discarded. Do not attempt to reuse a
+  # producer that has experienced a fatal error.
+  module Testing
+    # Triggers a test fatal error using rd_kafka_test_fatal_error.
+    # This is useful for testing fatal error handling without needing actual broker issues.
+    #
+    # @param error_code [Integer] The error code to trigger (e.g., 47 for invalid_producer_epoch)
+    # @param reason [String] Descriptive reason for the error
+    # @return [Integer] Result code from rd_kafka_test_fatal_error (0 on success)
+    #
+    # @example
+    #   producer.trigger_test_fatal_error(47, "Test producer fencing")
+    def trigger_test_fatal_error(error_code, reason)
+      @native_kafka.with_inner do |inner|
+        Rdkafka::Bindings.rd_kafka_test_fatal_error(inner, error_code, reason)
+      end
+    end
+
+    # Checks if a fatal error has occurred and retrieves error details.
+    # Calls rd_kafka_fatal_error to get the actual fatal error code and message.
+    #
+    # @return [Hash, nil] Hash with :error_code and :error_string if fatal error occurred, nil otherwise
+    #
+    # @example
+    #   if fatal_error = producer.fatal_error
+    #     puts "Fatal error #{fatal_error[:error_code]}: #{fatal_error[:error_string]}"
+    #   end
+    def fatal_error
+      @native_kafka.with_inner do |inner|
+        Rdkafka::Bindings.extract_fatal_error(inner)
+      end
+    end
+  end
+end

data/lib/rdkafka/producer.rb

@@ -142,7 +142,7 @@ module Rdkafka
       @native_kafka.with_inner do |inner|
         response_ptr = Rdkafka::Bindings.rd_kafka_init_transactions(inner, -1)
 
-        Rdkafka::RdkafkaError.validate!(response_ptr) || true
+        Rdkafka::RdkafkaError.validate!(response_ptr, client_ptr: inner) || true
       end
     end
 
@@ -152,7 +152,7 @@ module Rdkafka
       @native_kafka.with_inner do |inner|
         response_ptr = Rdkafka::Bindings.rd_kafka_begin_transaction(inner)
 
-        Rdkafka::RdkafkaError.validate!(response_ptr) || true
+        Rdkafka::RdkafkaError.validate!(response_ptr, client_ptr: inner) || true
       end
     end
 
@@ -162,7 +162,7 @@ module Rdkafka
       @native_kafka.with_inner do |inner|
         response_ptr = Rdkafka::Bindings.rd_kafka_commit_transaction(inner, timeout_ms)
 
-        Rdkafka::RdkafkaError.validate!(response_ptr) || true
+        Rdkafka::RdkafkaError.validate!(response_ptr, client_ptr: inner) || true
       end
     end
 
@@ -171,7 +171,7 @@ module Rdkafka
 
       @native_kafka.with_inner do |inner|
         response_ptr = Rdkafka::Bindings.rd_kafka_abort_transaction(inner, timeout_ms)
-        Rdkafka::RdkafkaError.validate!(response_ptr) || true
+        Rdkafka::RdkafkaError.validate!(response_ptr, client_ptr: inner) || true
       end
     end
 
@@ -192,7 +192,7 @@ module Rdkafka
       @native_kafka.with_inner do |inner|
         response_ptr = Bindings.rd_kafka_send_offsets_to_transaction(inner, native_tpl, cgmetadata, timeout_ms)
 
-        Rdkafka::RdkafkaError.validate!(response_ptr)
+        Rdkafka::RdkafkaError.validate!(response_ptr, client_ptr: inner)
       end
     ensure
       if cgmetadata && !cgmetadata.null?
@@ -266,7 +266,7 @@ module Rdkafka
           Bindings::RD_KAFKA_PURGE_F_QUEUE | Bindings::RD_KAFKA_PURGE_F_INFLIGHT
         )
 
-        Rdkafka::RdkafkaError.validate!(response)
+        Rdkafka::RdkafkaError.validate!(response, client_ptr: inner)
       end
 
       # Wait for the purge to affect everything
@@ -278,7 +278,7 @@ module Rdkafka
     # Partition count for a given topic.
     #
     # @param topic [String] The topic name.
-    # @return [Integer] partition count for a given topic or `-1` if it could not be obtained.
+    # @return [Integer] partition count for a given topic or `RD_KAFKA_PARTITION_UA (-1)` if it could not be obtained.
     #
     # @note If 'allow.auto.create.topics' is set to true in the broker, the topic will be
     #   auto-created after returning nil.
@@ -299,13 +299,13 @@ module Rdkafka
           topic_metadata = ::Rdkafka::Metadata.new(inner, topic).topics&.first
         end
 
-        topic_metadata ? topic_metadata[:partition_count] : -1
+        topic_metadata ? topic_metadata[:partition_count] : Rdkafka::Bindings::RD_KAFKA_PARTITION_UA
       end
     rescue Rdkafka::RdkafkaError => e
       # If the topic does not exist, it will be created or if not allowed another error will be
-      # raised. We here return -1 so this can happen without early error happening on metadata
-      # discovery.
-      return -1 if e.code == :unknown_topic_or_part
+      # raised. We here return RD_KAFKA_PARTITION_UA so this can happen without early error
+      # happening on metadata discovery.
+      return Rdkafka::Bindings::RD_KAFKA_PARTITION_UA if e.code == :unknown_topic_or_part
 
       raise(e)
     end
@@ -380,9 +380,9 @@ module Rdkafka
           selected_partitioner) if partition_count.positive?
       end
 
-      # If partition is nil, use -1 to let librdafka set the partition randomly or
+      # If partition is nil, use RD_KAFKA_PARTITION_UA to let librdafka set the partition randomly or
       # based on the key when present.
-      partition ||= -1
+      partition ||= Rdkafka::Bindings::RD_KAFKA_PARTITION_UA
 
       # If timestamp is nil use 0 and let Kafka set one. If an integer or time
       # use it.
@@ -400,9 +400,9 @@ module Rdkafka
       delivery_handle.label = label
       delivery_handle.topic = topic
       delivery_handle[:pending] = true
-      delivery_handle[:response] = -1
-      delivery_handle[:partition] = -1
-      delivery_handle[:offset] = -1
+      delivery_handle[:response] = Rdkafka::Bindings::RD_KAFKA_PARTITION_UA
+      delivery_handle[:partition] = Rdkafka::Bindings::RD_KAFKA_PARTITION_UA
+      delivery_handle[:offset] = Rdkafka::Bindings::RD_KAFKA_PARTITION_UA
       DeliveryHandle.register(delivery_handle)
 
       args = [
@@ -454,9 +454,12 @@ module Rdkafka
       end
 
       # Raise error if the produce call was not successful
-      if response != 0
+      if response != Rdkafka::Bindings::RD_KAFKA_RESP_ERR_NO_ERROR
         DeliveryHandle.remove(delivery_handle.to_ptr.address)
-        Rdkafka::RdkafkaError.validate!(response)
+
+        @native_kafka.with_inner do |inner|
+          Rdkafka::RdkafkaError.validate!(response, client_ptr: inner)
+        end
       end
 
       delivery_handle

data/lib/rdkafka/version.rb

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 
 module Rdkafka
-  VERSION = "0.23.0.beta1"
-  LIBRDKAFKA_VERSION = "2.12.0"
-  LIBRDKAFKA_SOURCE_SHA256 = "1355d81091d13643aed140ba0fe62437c02d9434b44e90975aaefab84c2bf237"
+  VERSION = "0.23.1"
+  LIBRDKAFKA_VERSION = "2.12.1"
+  LIBRDKAFKA_SOURCE_SHA256 = "ec103fa05cb0f251e375f6ea0b6112cfc9d0acd977dc5b69fdc54242ba38a16f"
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: karafka-rdkafka
 version: !ruby/object:Gem::Version
-  version: 0.23.0.beta1
+  version: 0.23.1
 platform: aarch64-linux-gnu
 authors:
 - Thijs Cadier
@@ -16,14 +16,14 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '1.15'
+        version: 1.17.1
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '1.15'
+        version: 1.17.1
 - !ruby/object:Gem::Dependency
   name: json
   requirement: !ruby/object:Gem::Requirement
@@ -222,6 +222,7 @@ files:
 - lib/rdkafka/producer/delivery_handle.rb
 - lib/rdkafka/producer/delivery_report.rb
 - lib/rdkafka/producer/partitions_count_cache.rb
+- lib/rdkafka/producer/testing.rb
 - lib/rdkafka/version.rb
 - renovate.json
 licenses: