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

data/lib/rdkafka/consumer.rb

@@ -35,11 +35,13 @@ module Rdkafka
     # consumer-queue reference, then destroy the native client. The default `NativeKafka#finalizer`
     # went straight to `rd_kafka_destroy`, leaving the consumer-queue reference (from
     # `rd_kafka_queue_get_consumer`, taken by `poll_batch`) dangling - which can make
-    # `rd_kafka_destroy` block inside the finalizer (process hang at GC/shutdown) or leak the handle.
+    # `rd_kafka_destroy` block inside the finalizer (process hang at GC/shutdown) or leak the
+    # handle.
     #
     # @private
     # @param native_kafka [NativeKafka] the wrapped native client
-    # @param queue_holder [Array] single-element holder carrying the consumer queue pointer (or empty)
+    # @param queue_holder [Array] single-element holder carrying the consumer queue pointer
+    #   (or empty)
     # @return [Proc] finalizer proc that must not reference the consumer instance
     def self.finalizer(native_kafka, queue_holder)
       proc do
@@ -125,11 +127,6 @@ module Rdkafka
     # @return [nil]
     # @raise [Rdkafka::ClosedConsumerError] if called on a closed consumer
     #
-    # @note This method holds the inner lock until the queue is empty or `:stop` is returned.
-    #   Other consumer operations will wait until this method returns.
-    # @note This method is thread-safe as it uses @native_kafka.with_inner synchronization
-    # @note Do NOT use this if `consumer_poll_set` was set to `true`
-    #
     # @example Drain all pending events
     #   consumer.events_poll_nb_each { |_count| }
     #
@@ -138,6 +135,10 @@ module Rdkafka
     #   consumer.events_poll_nb_each do |_count|
     #     :stop if monotonic_now >= deadline
     #   end
+    # @note This method holds the inner lock until the queue is empty or `:stop` is returned.
+    #   Other consumer operations will wait until this method returns.
+    # @note This method is thread-safe as it uses @native_kafka.with_inner synchronization
+    # @note Do NOT use this if `consumer_poll_set` was set to `true`
     def events_poll_nb_each
       closed_consumer_check(__method__)
 
@@ -163,14 +164,6 @@ module Rdkafka
     # @raise [Rdkafka::ClosedConsumerError] if called on a closed consumer
     # @raise [Rdkafka::RdkafkaError] if a Kafka error occurs while polling
     #
-    # @note This method uses `rd_kafka_consumer_poll` to fetch messages, unlike
-    #   `events_poll_nb_each` which uses `rd_kafka_poll` for event callbacks (delivery reports,
-    #   statistics, etc.). For consumers, use this method to receive messages and
-    #   `events_poll_nb_each` for processing background events.
-    # @note This method holds the inner lock for the duration. Other consumer operations
-    #   will wait until this method returns.
-    # @note Timeout/max_messages logic should be implemented by the caller
-    #
     # @example Process messages until queue is empty
     #   consumer.poll_nb_each do |message|
     #     process(message)
@@ -183,6 +176,13 @@ module Rdkafka
     #     count += 1
     #     :stop if count >= 10
     #   end
+    # @note This method uses `rd_kafka_consumer_poll` to fetch messages, unlike
+    #   `events_poll_nb_each` which uses `rd_kafka_poll` for event callbacks (delivery reports,
+    #   statistics, etc.). For consumers, use this method to receive messages and
+    #   `events_poll_nb_each` for processing background events.
+    # @note This method holds the inner lock for the duration. Other consumer operations
+    #   will wait until this method returns.
+    # @note Timeout/max_messages logic should be implemented by the caller
     def poll_nb_each
       closed_consumer_check(__method__)
 
@@ -437,9 +437,11 @@ module Rdkafka
     end
 
     # Return the current positions (offsets) for topics and partitions.
-    # The offset field of each requested partition will be set to the offset of the last consumed message + 1, or nil in case there was no previous message.
+    # The offset field of each requested partition will be set to the offset of the last consumed
+    # message + 1, or nil in case there was no previous message.
     #
-    # @param list [TopicPartitionList, nil] The topic with partitions to get the offsets for or nil to use the current subscription.
+    # @param list [TopicPartitionList, nil] The topic with partitions to get the offsets for or nil
+    #   to use the current subscription.
     #
     # @return [TopicPartitionList]
     #
@@ -592,7 +594,7 @@ module Rdkafka
     # When using this `enable.auto.offset.store` should be set to `false` in the config.
     #
     # @param message [Rdkafka::Consumer::Message] The message which offset will be stored
-    # @param metadata [String, nil] commit metadata string or nil if none
+    # @param metadata [String, nil] commit metadata string to store alongside the offset
     # @return [nil]
     # @raise [RdkafkaError] When storing the offset fails
     def store_offset(message, metadata = nil)
@@ -646,9 +648,8 @@ module Rdkafka
       seek_by(message.topic, message.partition, message.offset)
     end
 
-    # Seek to a particular message by providing the topic, partition and offset.
-    # The next poll on the topic/partition will return the
-    # message at the given offset.
+    # Seek to a particular message by providing the topic, partition and offset. The next poll on
+    # the topic/partition will return the message at the given offset.
     #
     # @param topic [String] The topic in which to seek
     # @param partition [Integer] The partition number to seek
@@ -875,7 +876,7 @@ module Rdkafka
     # returns without further waiting.
     #
     # Error events (e.g. `:partition_eof`) are returned inline as {RdkafkaError} objects
-    # rather than raised, so callers receive the complete batch — both messages and errors —
+    # rather than raised, so callers receive the complete batch - both messages and errors -
     # and can decide how to handle each. This is particularly useful when multiple partitions
     # signal EOF simultaneously: all signals appear in the returned array rather than only
     # the first one being raised and the rest silently discarded.
@@ -905,33 +906,35 @@ module Rdkafka
       begin
         while i < count
           ptr = buffer.get_pointer(i * FFI::Pointer.size)
+          # Take ownership of this index before processing the pointer: advancing `i` up front means
+          # the cleanup loop in the `ensure` below starts past it, so a raise mid-iteration cannot
+          # double-free the same message.
+          i += 1
 
-          if ptr.null?
-            i += 1
-            next
-          end
+          next if ptr.null?
 
-          native_message = Rdkafka::Bindings::Message.new(ptr)
+          # One `ensure` around the whole body guarantees `ptr` is destroyed exactly once on every
+          # path - the error branch, a successful build, a rescued `RdkafkaError`, or any other
+          # exception unwinding through here - so nothing leaks in the window before the build.
+          begin
+            native_message = Rdkafka::Bindings::Message.new(ptr)
 
-          if native_message[:err] != Rdkafka::Bindings::RD_KAFKA_RESP_ERR_NO_ERROR
-            results << build_batch_error(native_message)
-            Rdkafka::Bindings.rd_kafka_message_destroy(ptr)
-            i += 1
-            next
-          end
+            if native_message[:err] != Rdkafka::Bindings::RD_KAFKA_RESP_ERR_NO_ERROR
+              results << build_batch_error(native_message)
+              next
+            end
 
-          begin
-            results << Rdkafka::Consumer::Message.new(native_message)
-          rescue Rdkafka::RdkafkaError => e
-            # A message that fails to build (e.g. a header read error) is surfaced inline as an
-            # error event rather than discarding the whole batch - including the messages already
-            # built - and raising, which silently lost them once their offsets had been stored.
-            results << e
+            begin
+              results << Rdkafka::Consumer::Message.new(native_message)
+            rescue Rdkafka::RdkafkaError => e
+              # A message that fails to build (e.g. a header read error) is surfaced inline as an
+              # error event rather than discarding the whole batch - including the messages already
+              # built - and raising, which silently lost them once their offsets had been stored.
+              results << e
+            end
           ensure
             Rdkafka::Bindings.rd_kafka_message_destroy(ptr)
           end
-
-          i += 1
         end
       ensure
         while i < count
@@ -950,15 +953,15 @@ module Rdkafka
     # particularly useful in fiber scheduler contexts where GVL release/reacquire
     # overhead is wasteful since we don't expect to wait.
     #
+    # @param timeout_ms [Integer] Timeout waiting for the first message
+    #   (default: 0 for non-blocking)
+    # @param max_items [Integer] Maximum number of messages to return per call
+    # @return [Array<Message, RdkafkaError>] Batch of messages and/or error events in arrival order
+    # @raise [ClosedConsumerError] When called on a closed consumer
     # @note Since the GVL is not released, a non-zero timeout_ms will block all Ruby
     #   threads/fibers for the duration. Use {#poll_batch} if you need a blocking wait.
     #
     # Error events are returned inline as {RdkafkaError} objects; see {#poll_batch} for details.
-    #
-    # @param timeout_ms [Integer] Timeout waiting for the first message (default: 0 for non-blocking)
-    # @param max_items [Integer] Maximum number of messages to return per call
-    # @return [Array<Message, RdkafkaError>] Batch of messages and/or error events in arrival order
-    # @raise [ClosedConsumerError] When called on a closed consumer
     def poll_batch_nb(timeout_ms = 0, max_items: 100)
       closed_consumer_check(__method__)
 
@@ -980,33 +983,35 @@ module Rdkafka
       begin
         while i < count
           ptr = buffer.get_pointer(i * FFI::Pointer.size)
+          # Take ownership of this index before processing the pointer: advancing `i` up front means
+          # the cleanup loop in the `ensure` below starts past it, so a raise mid-iteration cannot
+          # double-free the same message.
+          i += 1
 
-          if ptr.null?
-            i += 1
-            next
-          end
+          next if ptr.null?
 
-          native_message = Rdkafka::Bindings::Message.new(ptr)
+          # One `ensure` around the whole body guarantees `ptr` is destroyed exactly once on every
+          # path - the error branch, a successful build, a rescued `RdkafkaError`, or any other
+          # exception unwinding through here - so nothing leaks in the window before the build.
+          begin
+            native_message = Rdkafka::Bindings::Message.new(ptr)
 
-          if native_message[:err] != Rdkafka::Bindings::RD_KAFKA_RESP_ERR_NO_ERROR
-            results << build_batch_error(native_message)
-            Rdkafka::Bindings.rd_kafka_message_destroy(ptr)
-            i += 1
-            next
-          end
+            if native_message[:err] != Rdkafka::Bindings::RD_KAFKA_RESP_ERR_NO_ERROR
+              results << build_batch_error(native_message)
+              next
+            end
 
-          begin
-            results << Rdkafka::Consumer::Message.new(native_message)
-          rescue Rdkafka::RdkafkaError => e
-            # A message that fails to build (e.g. a header read error) is surfaced inline as an
-            # error event rather than discarding the whole batch - including the messages already
-            # built - and raising, which silently lost them once their offsets had been stored.
-            results << e
+            begin
+              results << Rdkafka::Consumer::Message.new(native_message)
+            rescue Rdkafka::RdkafkaError => e
+              # A message that fails to build (e.g. a header read error) is surfaced inline as an
+              # error event rather than discarding the whole batch - including the messages already
+              # built - and raising, which silently lost them once their offsets had been stored.
+              results << e
+            end
           ensure
             Rdkafka::Bindings.rd_kafka_message_destroy(ptr)
           end
-
-          i += 1
         end
       ensure
         while i < count
@@ -1085,7 +1090,15 @@ module Rdkafka
 
     private
 
-    # Copies a librdkafka-allocated C string into a Ruby string and frees the native buffer.
+    # Checks if the consumer is closed and raises an error if so
+    # @param method [Symbol] name of the calling method for error context
+    # @raise [ClosedConsumerError] when the consumer is closed
+    def closed_consumer_check(method)
+      raise Rdkafka::ClosedConsumerError.new(method) if closed?
+    end
+    alias_method :closed_check, :closed_consumer_check
+
+    # Reads a librdkafka-allocated string and frees the underlying native buffer.
     #
     # `rd_kafka_memberid`/`rd_kafka_clusterid` return a string the caller owns and must release
     # with `rd_kafka_mem_free`; without this the buffer leaks on every call.
@@ -1101,14 +1114,6 @@ module Rdkafka
       Rdkafka::Bindings.rd_kafka_mem_free(inner, ptr) unless ptr.null?
     end
 
-    # Checks if the consumer is closed and raises an error if so
-    # @param method [Symbol] name of the calling method for error context
-    # @raise [ClosedConsumerError] when the consumer is closed
-    def closed_consumer_check(method)
-      raise Rdkafka::ClosedConsumerError.new(method) if closed?
-    end
-    alias_method :closed_check, :closed_consumer_check
-
     # Reads this consumer's effective `isolation.level` from the live librdkafka configuration
     # and maps it to the numeric isolation level constant. Memoized: the value cannot change
     # after client creation.

data/lib/rdkafka/defaults.rb

@@ -3,8 +3,17 @@
 module Rdkafka
   # Provides default timeout and configuration values used throughout the library.
   #
-  # These constants standardize timing values across consumers, producers, and admin clients.
-  # Values are specified in milliseconds (ms) unless otherwise noted.
+  # All timeout values can be overridden per-call via method parameters. These constants provide
+  # a central place to understand and reference the default values used across the library.
+  #
+  # @example Overriding a timeout per-call
+  #   consumer.committed(timeout_ms: 5_000)  # Use 5 seconds instead of default 2 seconds
+  #
+  # @example Checking the default value
+  #   Rdkafka::Defaults::CONSUMER_COMMITTED_TIMEOUT_MS  # => 2000
+  # @note These are rdkafka-ruby defaults, not librdkafka configuration options.
+  #   For librdkafka options, see:
+  #   https://github.com/confluentinc/librdkafka/blob/master/CONFIGURATION.md
   module Defaults
     # Consumer timeout for fetching committed offsets
     # @see Consumer#committed

data/lib/rdkafka/error.rb

@@ -139,7 +139,8 @@ module Rdkafka
       # 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_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
       # @param instance_name [String, nil] Optional name of the rdkafka instance
       # @return [RdkafkaError] Error object with fatal flag set to true

data/lib/rdkafka/helpers/oauth.rb

@@ -4,10 +4,14 @@ module Rdkafka
     module OAuth
       # Set the OAuthBearer token
       #
-      # @param token [String] the mandatory token value to set, often (but not necessarily) a JWS compact serialization as per https://tools.ietf.org/html/rfc7515#section-3.1.
-      # @param lifetime_ms [Integer] when the token expires, in terms of the number of milliseconds since the epoch. See https://currentmillis.com/.
+      # @param token [String] the mandatory token value to set, often (but not necessarily) a JWS
+      #   compact serialization as per https://tools.ietf.org/html/rfc7515#section-3.1.
+      # @param lifetime_ms [Integer] when the token expires, in terms of the number of milliseconds
+      #   since the epoch. See https://currentmillis.com/.
       # @param principal_name [String] the mandatory Kafka principal name associated with the token.
-      # @param extensions [Hash] optional SASL extensions key-value pairs to be communicated to the broker as additional key-value pairs during the initial client response as per https://tools.ietf.org/html/rfc7628#section-3.1.
+      # @param extensions [Hash] optional SASL extensions key-value pairs to be communicated to the
+      #   broker as additional key-value pairs during the initial client response as per
+      #   https://tools.ietf.org/html/rfc7628#section-3.1.
       # @return [Integer] 0 on success
       def oauthbearer_set_token(token:, lifetime_ms:, principal_name:, extensions: nil)
         error_buffer = FFI::MemoryPointer.from_string(" " * 256)
@@ -49,7 +53,8 @@ module Rdkafka
       # Convert extensions hash to FFI::MemoryPointer (`const char **`).
       #
       # @param extensions [Hash, nil] extension key-value pairs
-      # @return [Array<FFI::MemoryPointer, Array<FFI::MemoryPointer>>] array pointer and string pointers
+      # @return [Array<FFI::MemoryPointer, Array<FFI::MemoryPointer>>] array pointer and string
+      #   pointers
       # @note The returned pointers must be freed manually (autorelease = false).
       def map_extensions(extensions)
         return [nil, nil] if extensions.nil? || extensions.empty?
@@ -80,7 +85,7 @@ module Rdkafka
       #
       # @param extensions [Hash, nil] extension key-value pairs
       # @return [Integer] non-negative even number representing keys + values count
-      # @see https://github.com/confluentinc/librdkafka/blob/master/src/rdkafka_sasl_oauthbearer.c#L327-L347
+      # @see github.com/confluentinc/librdkafka/blob/master/src/rdkafka_sasl_oauthbearer.c#L327-L347
       def extension_size(extensions)
         return 0 unless extensions
         extensions.size * 2

data/lib/rdkafka/native_kafka.rb

@@ -13,6 +13,14 @@ module Rdkafka
     def initialize(inner, run_polling_thread:, opaque:, auto_start: true, timeout_ms: Defaults::NATIVE_KAFKA_POLL_TIMEOUT_MS)
       @inner = inner
       @opaque = opaque
+      # Process that owns `@inner`. librdkafka is not fork-safe: `fork` copies only the calling
+      # thread, so the background/broker threads backing this handle do not exist in a child
+      # process. An inherited handle therefore must not be polled or destroyed in the child -
+      # `rd_kafka_destroy` would walk thread state that no longer exists (segfault) and the
+      # inherited mutexes may have been copied in a locked state (deadlock). We record the creator
+      # pid so a forked child can recognise an inherited handle and leave its teardown to the
+      # parent, which still owns the running threads.
+      @creator_pid = Process.pid
       # Lock around external access
       @access_mutex = Mutex.new
       # Lock around internal polling
@@ -116,17 +124,21 @@ module Rdkafka
     end
 
     # Returns whether this native Kafka handle is closed or closing
+    #
+    # A handle inherited across `fork` is reported as closed in the child: it belongs to another
+    # process whose threads back the native client, so it is not usable here and must not be
+    # destroyed here (see the `@creator_pid` note in `#initialize`). This makes every `#close`
+    # path - including the GC finalizers that run during a child's exit - skip the native teardown
+    # for inherited handles, which is what would otherwise segfault the child.
+    #
     # @return [Boolean] true if closed or closing
     def closed?
-      @closing || @inner.nil?
+      @closing || @inner.nil? || @creator_pid != Process.pid
     end
 
     # Enable IO event notifications on the main queue
     # Librdkafka will write to your FD when the queue transitions from empty to non-empty
     #
-    # @note This method is incompatible with background polling threads.
-    #   If background polling is enabled, use manual polling instead (e.g., consumer.poll)
-    #
     # @param fd [Integer] your file descriptor (from IO.pipe or eventfd)
     # @param payload [String] data to write to fd when queue has data (default: "\x01")
     # @return [nil]
@@ -143,6 +155,8 @@ module Rdkafka
     #   if readable
     #     consumer.poll(0)  # Get messages
     #   end
+    # @note This method is incompatible with background polling threads.
+    #   If background polling is enabled, use manual polling instead (e.g., consumer.poll)
     def enable_main_queue_io_events(fd, payload = "\x01")
       if @run_polling_thread
         raise "Cannot enable IO events while background polling thread is active. " \
@@ -160,14 +174,13 @@ module Rdkafka
     # Enable IO event notifications on the background queue
     # Librdkafka will write to your FD when the background queue transitions from empty to non-empty
     #
-    # @note This method is incompatible with background polling threads.
-    #   If background polling is enabled, use manual polling instead (e.g., consumer.poll)
-    #
     # @param fd [Integer] your file descriptor (from IO.pipe or eventfd)
     # @param payload [String] data to write to fd when queue has data (default: "\x01")
     # @return [nil]
     # @raise [ClosedInnerError] when the handle is closed
     # @raise [RuntimeError] when background polling thread is active
+    # @note This method is incompatible with background polling threads.
+    #   If background polling is enabled, use manual polling instead (e.g., consumer.poll)
     def enable_background_queue_io_events(fd, payload = "\x01")
       if @run_polling_thread
         raise "Cannot enable IO events while background polling thread is active. " \

data/lib/rdkafka/producer/delivery_handle.rb

@@ -2,8 +2,7 @@
 
 module Rdkafka
   class Producer
-    # Handle to wait for a delivery report which is returned when
-    # producing a message.
+    # Handle to wait for a delivery report which is returned when producing a message.
     class DeliveryHandle < Rdkafka::AbstractHandle
       layout :pending, :bool,
         :response, :int,

data/lib/rdkafka/producer/testing.rb

@@ -36,7 +36,8 @@ module Rdkafka
     # 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
+    # @return [Hash, nil] Hash with :error_code and :error_string if fatal error occurred,
+    #   nil otherwise
     #
     # @example
     #   if fatal_error = producer.fatal_error

data/lib/rdkafka/producer.rb

@@ -1,13 +1,14 @@
 # frozen_string_literal: true
 
 module Rdkafka
-  # A producer for Kafka messages. To create a producer set up a {Config} and call {Config#producer producer} on that.
+  # A producer for Kafka messages. To create a producer set up a {Config} and call
+  # {Config#producer producer} on that.
   class Producer
     include Helpers::Time
     include Helpers::OAuth
     include Helpers::Metadata
 
-    # @private
+    # @!visibility private
     @@partitions_count_cache = PartitionsCountCache.new
 
     # Global (process wide) partitions cache. We use it to store number of topics partitions,
@@ -175,8 +176,7 @@ module Rdkafka
       end
     end
 
-    # Begin a new transaction
-    # Requires {#init_transactions} to have been called first
+    # Begin a new transaction. Requires {#init_transactions} to have been called first
     #
     # @return [true] Returns true on success
     # @raise [RdkafkaError] if beginning the transaction fails
@@ -331,10 +331,9 @@ module Rdkafka
     # @return [Integer] the number of messages in the queue
     # @raise [Rdkafka::ClosedProducerError] if called on a closed producer
     #
-    # @note This method is thread-safe as it uses the @native_kafka.with_inner synchronization
-    #
     # @example
     #   producer.queue_size #=> 42
+    # @note This method is thread-safe as it uses the @native_kafka.with_inner synchronization
     def queue_size
       closed_producer_check(__method__)
 
@@ -360,10 +359,6 @@ module Rdkafka
     # @return [nil]
     # @raise [Rdkafka::ClosedProducerError] if called on a closed producer
     #
-    # @note This method holds the inner lock until the queue is empty or `:stop` is returned.
-    #   Other producer operations (produce, close, etc.) will wait until this method returns.
-    # @note This method is thread-safe as it uses @native_kafka.with_inner synchronization
-    #
     # @example Drain all pending callbacks
     #   producer.events_poll_nb_each { |_count| }
     #
@@ -372,6 +367,9 @@ module Rdkafka
     #   producer.events_poll_nb_each do |_count|
     #     :stop if monotonic_now >= deadline
     #   end
+    # @note This method holds the inner lock until the queue is empty or `:stop` is returned.
+    #   Other producer operations (produce, close, etc.) will wait until this method returns.
+    # @note This method is thread-safe as it uses @native_kafka.with_inner synchronization
     def events_poll_nb_each
       closed_producer_check(__method__)
 
@@ -387,7 +385,8 @@ module Rdkafka
     # Partition count for a given topic.
     #
     # @param topic [String] The topic name.
-    # @return [Integer] partition count for a given topic or `RD_KAFKA_PARTITION_UA (-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.
@@ -422,23 +421,32 @@ module Rdkafka
       end
     end
 
-    # Produces a message to a Kafka topic. The message is added to rdkafka's queue, call {DeliveryHandle#wait wait} on the returned delivery handle to make sure it is delivered.
+    # Produces a message to a Kafka topic. The message is added to rdkafka's queue, call
+    # {DeliveryHandle#wait wait} on the returned delivery handle to make sure it is delivered.
     #
-    # When no partition is specified the underlying Kafka library picks a partition based on the key. If no key is specified, a random partition will be used.
-    # When a timestamp is provided this is used instead of the auto-generated timestamp.
+    # When no partition is specified the underlying Kafka library picks a partition based on the
+    # key. If no key is specified, a random partition will be used. When a timestamp is provided
+    # this is used instead of the auto-generated timestamp.
     #
     # @param topic [String] The topic to produce to
     # @param payload [String, nil]
     # @param key [String, nil]
     # @param partition [Integer, nil] Optional partition to produce to
-    # @param partition_key [String, nil] Optional partition key based on which partition assignment can happen
-    # @param timestamp [Time, Integer, nil] Optional timestamp of this message. Integer timestamp is in milliseconds since Jan 1 1970.
-    # @param headers [Hash{String => String, Array<String>}] Optional message headers. Values can be either a single string or an array of strings to support duplicate headers per KIP-82
-    # @param label [Object, nil] a label that can be assigned when producing a message that will be part of the delivery handle and the delivery report
-    # @param topic_config [Hash] topic config for given message dispatch. Allows to send messages to topics with different configuration
+    # @param partition_key [String, nil] Optional partition key based on which partition
+    #   assignment can happen
+    # @param timestamp [Time, Integer, nil] Optional timestamp of this message. Integer
+    #   timestamp is in milliseconds since Jan 1 1970.
+    # @param headers [Hash{String => String, Array<String>}] Optional message headers. Values
+    #   can be either a single string or an array of strings to support duplicate headers per
+    #   KIP-82
+    # @param label [Object, nil] a label that can be assigned when producing a message that
+    #   will be part of the delivery handle and the delivery report
+    # @param topic_config [Hash] topic config for given message dispatch. Allows to send
+    #   messages to topics with different configuration
     # @param partitioner [String] name of the partitioner to use
     #
-    # @return [DeliveryHandle] Delivery handle that can be used to wait for the result of producing this message
+    # @return [DeliveryHandle] Delivery handle that can be used to wait for the result of
+    #   producing this message
     #
     # @raise [RdkafkaError] When adding the message to rdkafka's queue failed
     def produce(

data/lib/rdkafka/version.rb

@@ -2,7 +2,7 @@
 
 module Rdkafka
   # Current rdkafka-ruby gem version
-  VERSION = "0.28.0"
+  VERSION = "0.28.2"
   # Target librdkafka version to be used
   LIBRDKAFKA_VERSION = "2.14.2"
   # SHA256 hash of the librdkafka source tarball for verification

data/lib/rdkafka.rb

@@ -17,6 +17,8 @@ require "rdkafka/admin/create_topic_handle"
 require "rdkafka/admin/create_topic_report"
 require "rdkafka/admin/delete_groups_handle"
 require "rdkafka/admin/delete_groups_report"
+require "rdkafka/admin/delete_records_handle"
+require "rdkafka/admin/delete_records_report"
 require "rdkafka/admin/delete_topic_handle"
 require "rdkafka/admin/delete_topic_report"
 require "rdkafka/admin/create_partitions_handle"
@@ -33,6 +35,8 @@ require "rdkafka/admin/incremental_alter_configs_handle"
 require "rdkafka/admin/incremental_alter_configs_report"
 require "rdkafka/admin/list_offsets_handle"
 require "rdkafka/admin/list_offsets_report"
+require "rdkafka/admin/list_consumer_groups_handle"
+require "rdkafka/admin/list_consumer_groups_report"
 require "rdkafka/admin/acl_binding_result"
 require "rdkafka/admin/config_binding_result"
 require "rdkafka/admin/config_resource_binding_result"
@@ -43,17 +47,20 @@ require "rdkafka/callbacks/create_topic_handler"
 require "rdkafka/callbacks/delete_topic_handler"
 require "rdkafka/callbacks/create_partitions_handler"
 require "rdkafka/callbacks/delete_groups_handler"
+require "rdkafka/callbacks/delete_records_handler"
 require "rdkafka/callbacks/create_acl_handler"
 require "rdkafka/callbacks/delete_acl_handler"
 require "rdkafka/callbacks/describe_acl_handler"
 require "rdkafka/callbacks/describe_configs_handler"
 require "rdkafka/callbacks/incremental_alter_configs_handler"
 require "rdkafka/callbacks/list_offsets_handler"
+require "rdkafka/callbacks/list_consumer_groups_handler"
 require "rdkafka/config"
 require "rdkafka/consumer"
 require "rdkafka/consumer/headers"
 require "rdkafka/consumer/message"
 require "rdkafka/consumer/partition"
+require "rdkafka/consumer/allocator"
 require "rdkafka/consumer/topic_partition_list"
 require "rdkafka/error"
 require "rdkafka/metadata"
@@ -62,9 +69,12 @@ require "rdkafka/producer/partitions_count_cache"
 require "rdkafka/producer"
 require "rdkafka/producer/delivery_handle"
 require "rdkafka/producer/delivery_report"
+require "rdkafka/clients"
 
 # Main Rdkafka namespace of this gem
 module Rdkafka
 end
 
 Rdkafka::Bindings.rd_kafka_global_init
+
+at_exit { Rdkafka::Clients.close_all }

data/package-lock.json

@@ -103,9 +103,9 @@
       }
     },
     "node_modules/fastq": {
-      "version": "1.20.1",
-      "resolved": "https://registry.npmjs.org/fastq/-/fastq-1.20.1.tgz",
-      "integrity": "sha512-GGToxJ/w1x32s/D2EKND7kTil4n8OVk/9mycTc4VDza13lOvpUZTGX3mFSCtV9ksdGBVzvsyAVLM6mHFThxXxw==",
+      "version": "1.20.2",
+      "resolved": "https://registry.npmjs.org/fastq/-/fastq-1.20.2.tgz",
+      "integrity": "sha512-UpGiiODyCGprM8EPP6JodP6jC9Rws6TCuiDOD+nn0CJhR8guI3g/ozo4ugL0vJ+Yz1UtJuuRPqvQuybVOF1VQA==",
       "dev": true,
       "license": "ISC",
       "dependencies": {
@@ -286,9 +286,9 @@
       }
     },
     "node_modules/smol-toml": {
-      "version": "1.7.0",
-      "resolved": "https://registry.npmjs.org/smol-toml/-/smol-toml-1.7.0.tgz",
-      "integrity": "sha512-aqVvWoyO21L23mb+drl4RmMXbf6N7FdHjAhTRA9ZBL7apWBgfWC16KjrASI+1p9GAroljyMHj6fK67i0UiTNvQ==",
+      "version": "1.8.0",
+      "resolved": "https://registry.npmjs.org/smol-toml/-/smol-toml-1.8.0.tgz",
+      "integrity": "sha512-kCZr2V3ch9i00x8zXRhjUNVcjG9ijES5dDudkXvUVCT5QlJNQWElSJdZqyPemffHoLNUYwOcou0Fy+ojN0uHSQ==",
       "dev": true,
       "license": "BSD-3-Clause",
       "engines": {

data/renovate.json

@@ -27,7 +27,7 @@
       ],
       "depNameTemplate": "openssl/openssl",
       "datasourceTemplate": "github-releases",
-      "extractVersionTemplate": "^OpenSSL_(?<version>.*)$"
+      "extractVersionTemplate": "^openssl-(?<version>.*)$"
     },
     {
       "customType": "regex",