karafka-rdkafka 0.23.1.rc2-x86_64-linux-gnu → 0.24.0.rc1-x86_64-linux-gnu

data/lib/rdkafka/error.rb

@@ -26,6 +26,12 @@ module Rdkafka
     attr_reader :details
 
     class << self
+      # Build an error instance from a rd_kafka_error_t pointer
+      #
+      # @param response_ptr [FFI::Pointer] Pointer to rd_kafka_error_t
+      # @param message_prefix [String, nil] Optional prefix for the error message
+      # @param broker_message [String, nil] Optional broker error message
+      # @return [RdkafkaError, false] Error instance or false if no error
       def build_from_c(response_ptr, message_prefix = nil, broker_message: nil)
         code = Rdkafka::Bindings.rd_kafka_error_code(response_ptr)
 
@@ -48,6 +54,13 @@ module Rdkafka
         )
       end
 
+      # Build an error instance from various input types
+      #
+      # @param response_ptr_or_code [Integer, FFI::Pointer, Bindings::Message] Error code, pointer,
+      #   or message struct
+      # @param message_prefix [String, nil] Optional prefix for the error message
+      # @param broker_message [String, nil] Optional broker error message
+      # @return [RdkafkaError, false] Error instance or false if no error
       def build(response_ptr_or_code, message_prefix = nil, broker_message: nil)
         case response_ptr_or_code
         when Integer
@@ -81,6 +94,16 @@ module Rdkafka
         end
       end
 
+      # Validate a response and raise an error if it indicates a failure
+      #
+      # @param response_ptr_or_code [Integer, FFI::Pointer, Bindings::Message] Error code, pointer,
+      #   or message struct
+      # @param message_prefix [String, nil] Optional prefix for the error message
+      # @param broker_message [String, nil] Optional broker error message
+      # @param client_ptr [FFI::Pointer, nil] Optional pointer to rd_kafka_t client for fatal error
+      #   detection
+      # @return [false] Returns false if no error
+      # @raise [RdkafkaError] if the response indicates an error
       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)
 
@@ -128,6 +151,13 @@ module Rdkafka
     end
 
     # @private
+    # @param response [Integer] the raw error response code from librdkafka
+    # @param message_prefix [String, nil] optional prefix for error messages
+    # @param broker_message [String, nil] optional error message from the broker
+    # @param fatal [Boolean] whether this is a fatal error
+    # @param retryable [Boolean] whether this error is retryable
+    # @param abortable [Boolean] whether this error requires transaction abort
+    # @param details [Hash] additional error details
     def initialize(
       response,
       message_prefix=nil,
@@ -183,18 +213,26 @@ module Rdkafka
     end
 
     # Error comparison
+    # @param another_error [Object] object to compare with
+    # @return [Boolean]
     def ==(another_error)
        another_error.is_a?(self.class) && (self.to_s == another_error.to_s)
     end
 
+    # Whether this error is fatal and the client instance is no longer usable
+    # @return [Boolean]
     def fatal?
       @fatal
     end
 
+    # Whether this error is retryable and the operation may succeed if retried
+    # @return [Boolean]
     def retryable?
       @retryable
     end
 
+    # Whether this error requires the current transaction to be aborted
+    # @return [Boolean]
     def abortable?
       @abortable
     end
@@ -206,6 +244,9 @@ module Rdkafka
     attr_reader :topic_partition_list
 
     # @private
+    # @param response [Integer] the raw error response code from librdkafka
+    # @param topic_partition_list [TopicPartitionList] the topic partition list with error info
+    # @param message_prefix [String, nil] optional prefix for error messages
     def initialize(response, topic_partition_list, message_prefix=nil)
       super(response, message_prefix)
       @topic_partition_list = topic_partition_list
@@ -214,6 +255,7 @@ module Rdkafka
 
   # Error class for public consumer method calls on a closed consumer.
   class ClosedConsumerError < BaseError
+    # @param method [Symbol] the method that was called
     def initialize(method)
       super("Illegal call to #{method.to_s} on a closed consumer")
     end
@@ -221,18 +263,21 @@ module Rdkafka
 
   # Error class for public producer method calls on a closed producer.
   class ClosedProducerError < BaseError
+    # @param method [Symbol] the method that was called
     def initialize(method)
       super("Illegal call to #{method.to_s} on a closed producer")
     end
   end
 
-  # Error class for public consumer method calls on a closed admin.
+  # Error class for public admin method calls on a closed admin.
   class ClosedAdminError < BaseError
+    # @param method [Symbol] the method that was called
     def initialize(method)
       super("Illegal call to #{method.to_s} on a closed admin")
     end
   end
 
+  # Error class for calls on a closed inner librdkafka instance.
   class ClosedInnerError < BaseError
     def initialize
       super("Illegal call to a closed inner librdkafka instance")

data/lib/rdkafka/helpers/oauth.rb

@@ -1,6 +1,6 @@
 module Rdkafka
   module Helpers
-
+    # OAuth helper methods for setting and refreshing SASL/OAUTHBEARER tokens
     module OAuth
 
       # Set the OAuthBearer token
@@ -47,8 +47,11 @@ module Rdkafka
 
       private
 
-      # Convert extensions hash to FFI::MemoryPointer (const char **).
-      # Note: the returned pointers must be freed manually (autorelease = false).
+      # 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
+      # @note The returned pointers must be freed manually (autorelease = false).
       def map_extensions(extensions)
         return [nil, nil] if extensions.nil? || extensions.empty?
 
@@ -74,8 +77,11 @@ module Rdkafka
         [array_ptr, str_ptrs]
       end
 
-      # extension_size is the number of keys + values which should be a non-negative even number
-      # https://github.com/confluentinc/librdkafka/blob/master/src/rdkafka_sasl_oauthbearer.c#L327-L347
+      # Returns the extension size (number of keys + values).
+      #
+      # @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
       def extension_size(extensions)
         return 0 unless extensions
         extensions.size * 2

data/lib/rdkafka/metadata.rb

@@ -1,8 +1,12 @@
 # frozen_string_literal: true
 
 module Rdkafka
+  # Provides cluster metadata information
   class Metadata
-    attr_reader :brokers, :topics
+    # @return [Array<Hash>] list of broker metadata
+    attr_reader :brokers
+    # @return [Array<Hash>] list of topic metadata
+    attr_reader :topics
 
     # Errors upon which we retry the metadata fetch
     RETRIED_ERRORS = %i[
@@ -12,7 +16,13 @@ module Rdkafka
 
     private_constant :RETRIED_ERRORS
 
-    def initialize(native_client, topic_name = nil, timeout_ms = 2_000)
+    # Fetches metadata from the Kafka cluster
+    #
+    # @param native_client [FFI::Pointer] pointer to the native Kafka client
+    # @param topic_name [String, nil] specific topic to fetch metadata for, or nil for all topics
+    # @param timeout_ms [Integer] timeout in milliseconds
+    # @raise [RdkafkaError] when metadata fetch fails
+    def initialize(native_client, topic_name = nil, timeout_ms = Defaults::METADATA_TIMEOUT_MS)
       attempt ||= 0
       attempt += 1
 
@@ -34,12 +44,12 @@ module Rdkafka
       metadata_from_native(ptr.read_pointer)
     rescue ::Rdkafka::RdkafkaError => e
       raise unless RETRIED_ERRORS.include?(e.code)
-      raise if attempt > 10
+      raise if attempt > Defaults::METADATA_MAX_RETRIES
 
       backoff_factor = 2**attempt
-      timeout = backoff_factor * 0.1
+      timeout_ms = backoff_factor * Defaults::METADATA_RETRY_BACKOFF_BASE_MS
 
-      sleep(timeout)
+      sleep(timeout_ms / 1_000.0)
 
       retry
     ensure
@@ -49,6 +59,8 @@ module Rdkafka
 
     private
 
+    # Extracts metadata from native pointer
+    # @param ptr [FFI::Pointer] pointer to native metadata
     def metadata_from_native(ptr)
       metadata = Metadata.new(ptr)
       @brokers = Array.new(metadata[:brokers_count]) do |i|
@@ -69,7 +81,11 @@ module Rdkafka
       end
     end
 
+    # Base class for metadata FFI structs with hash conversion
+    # @private
     class CustomFFIStruct < FFI::Struct
+      # Converts struct to a hash
+      # @return [Hash]
       def to_h
         members.each_with_object({}) do |mem, hsh|
           val = self.[](mem)
@@ -80,6 +96,8 @@ module Rdkafka
       end
     end
 
+    # @private
+    # FFI struct for rd_kafka_metadata_t
     class Metadata < CustomFFIStruct
       layout :brokers_count, :int,
              :brokers_metadata, :pointer,
@@ -89,12 +107,16 @@ module Rdkafka
              :broker_name, :string
     end
 
+    # @private
+    # FFI struct for rd_kafka_metadata_broker_t
     class BrokerMetadata < CustomFFIStruct
       layout :broker_id, :int32,
              :broker_name, :string,
              :broker_port, :int
     end
 
+    # @private
+    # FFI struct for rd_kafka_metadata_topic_t
     class TopicMetadata < CustomFFIStruct
       layout :topic_name, :string,
              :partition_count, :int,
@@ -102,6 +124,8 @@ module Rdkafka
              :rd_kafka_resp_err, :int
     end
 
+    # @private
+    # FFI struct for rd_kafka_metadata_partition_t
     class PartitionMetadata < CustomFFIStruct
       layout :partition_id, :int32,
              :rd_kafka_resp_err, :int,

data/lib/rdkafka/native_kafka.rb

@@ -4,7 +4,13 @@ module Rdkafka
   # @private
   # A wrapper around a native kafka that polls and cleanly exits
   class NativeKafka
-    def initialize(inner, run_polling_thread:, opaque:, auto_start: true, timeout_ms: 100)
+    # Creates a new NativeKafka wrapper
+    # @param inner [FFI::Pointer] pointer to the native Kafka handle
+    # @param run_polling_thread [Boolean] whether to run a background polling thread
+    # @param opaque [Rdkafka::Opaque] opaque object for callback context
+    # @param auto_start [Boolean] whether to start the polling thread automatically
+    # @param timeout_ms [Integer] poll timeout in milliseconds
+    def initialize(inner, run_polling_thread:, opaque:, auto_start: true, timeout_ms: Defaults::NATIVE_KAFKA_POLL_TIMEOUT_MS)
       @inner = inner
       @opaque = opaque
       # Lock around external access
@@ -37,6 +43,8 @@ module Rdkafka
       @closing = false
     end
 
+    # Starts the polling thread if configured
+    # @return [nil]
     def start
       synchronize do
         return if @started
@@ -69,6 +77,10 @@ module Rdkafka
       end
     end
 
+    # Executes a block with the inner native Kafka handle
+    # @yield [FFI::Pointer] the inner native Kafka handle
+    # @return [Object] the result of the block
+    # @raise [ClosedInnerError] when the inner handle is nil
     def with_inner
       if @access_mutex.owned?
         @operations_in_progress += 1
@@ -81,26 +93,38 @@ module Rdkafka
       @decrement_mutex.synchronize { @operations_in_progress -= 1 }
     end
 
+    # Executes a block while holding exclusive access to the native Kafka handle
+    # @param block [Proc] block to execute with the native handle
+    # @yield [FFI::Pointer] the inner native Kafka handle
+    # @return [Object] the result of the block
     def synchronize(&block)
       @access_mutex.synchronize do
         # Wait for any commands using the inner to finish
         # This can take a while on blocking operations like polling but is essential not to proceed
         # with certain types of operations like resources destruction as it can cause the process
         # to hang or crash
-        sleep(0.01) until @operations_in_progress.zero?
+        sleep(Defaults::NATIVE_KAFKA_SYNCHRONIZE_SLEEP_INTERVAL_MS / 1_000.0) until @operations_in_progress.zero?
 
         with_inner(&block)
       end
     end
 
+    # Returns a finalizer proc for closing this native Kafka handle
+    # @return [Proc] finalizer proc
     def finalizer
       ->(_) { close }
     end
 
+    # Returns whether this native Kafka handle is closed or closing
+    # @return [Boolean] true if closed or closing
     def closed?
       @closing || @inner.nil?
     end
 
+    # Closes the native Kafka handle and cleans up resources
+    # @param object_id [Integer, nil] optional object ID (unused, for finalizer compatibility)
+    # @yield optional block to execute before destroying the handle
+    # @return [nil]
     def close(object_id=nil)
       return if closed?
 

data/lib/rdkafka/producer/delivery_report.rb

@@ -32,8 +32,12 @@ module Rdkafka
       # We do not remove the original `#topic_name` because of backwards compatibility
       alias topic topic_name
 
-      private
-
+      # @private
+      # @param partition [Integer] partition number
+      # @param offset [Integer] message offset
+      # @param topic_name [String, nil] topic name
+      # @param error [Integer, nil] error code if any
+      # @param label [Object, nil] user-defined label
       def initialize(partition, offset, topic_name = nil, error = nil, label = nil)
         @partition = partition
         @offset = offset

data/lib/rdkafka/producer/partitions_count_cache.rb

@@ -17,9 +17,9 @@ module Rdkafka
     #
     # 2. Edge case handling
     #    If a user configures `statistics.interval.ms` much higher than the default cache TTL
-    #    (30 seconds), the cache will still function correctly. When statistics updates don't
-    #    occur frequently enough, the cache entries will expire naturally, triggering a
-    #    blocking refresh when needed.
+    #    ({Defaults::PARTITIONS_COUNT_CACHE_TTL_MS}ms), the cache will still function correctly.
+    #    When statistics updates don't occur frequently enough, the cache entries will expire
+    #    naturally, triggering a blocking refresh when needed.
     #
     # 3. User configuration awareness
     #    The cache respects user-defined settings. If `topic.metadata.refresh.interval.ms` is
@@ -46,22 +46,32 @@ module Rdkafka
     class PartitionsCountCache
       include Helpers::Time
 
-      # Default time-to-live for cached partition counts in seconds
-      #
-      # @note This default was chosen to balance freshness of metadata with performance
-      #   optimization. Most Kafka cluster topology changes are planned operations, making 30
-      #   seconds a reasonable compromise.
-      DEFAULT_TTL = 30
-
       # Creates a new partition count cache
       #
-      # @param ttl [Integer] Time-to-live in seconds for cached values
-      def initialize(ttl = DEFAULT_TTL)
+      # @param ttl [Integer, nil] DEPRECATED: Use ttl_ms instead.
+      #   Time-to-live in seconds for cached values. Will be removed in v1.0.0.
+      # @param ttl_ms [Integer, nil] Time-to-live in milliseconds for cached values.
+      #   Defaults to {Defaults::PARTITIONS_COUNT_CACHE_TTL_MS}.
+      def initialize(ttl = :not_provided, ttl_ms: :not_provided)
         @counts = {}
         @mutex_hash = {}
         # Used only for @mutex_hash access to ensure thread-safety when creating new mutexes
         @mutex_for_hash = Mutex.new
-        @ttl = ttl
+
+        # Determine which TTL value to use
+        if ttl != :not_provided && ttl_ms != :not_provided
+          warn "DEPRECATION WARNING: Both ttl and ttl_ms were provided to PartitionsCountCache. " \
+               "Using ttl_ms. The ttl parameter is deprecated and will be removed in v1.0.0."
+          @ttl_ms = ttl_ms
+        elsif ttl != :not_provided
+          warn "DEPRECATION WARNING: ttl (seconds) parameter for PartitionsCountCache is deprecated. " \
+               "Use ttl_ms (milliseconds) instead. This parameter will be removed in v1.0.0."
+          @ttl_ms = (ttl * 1000).to_i
+        elsif ttl_ms == :not_provided
+          @ttl_ms = Defaults::PARTITIONS_COUNT_CACHE_TTL_MS
+        else
+          @ttl_ms = ttl_ms
+        end
       end
 
       # Reads partition count for a topic with automatic refresh when expired
@@ -209,7 +219,7 @@ module Rdkafka
       # @param timestamp [Float] Monotonic timestamp to check
       # @return [Boolean] true if expired, false otherwise
       def expired?(timestamp)
-        monotonic_now - timestamp > @ttl
+        (monotonic_now - timestamp) * 1_000 > @ttl_ms
       end
     end
   end

data/lib/rdkafka/producer/testing.rb

@@ -14,9 +14,9 @@ module Rdkafka
   # 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.
+  # @note 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.

data/lib/rdkafka/producer.rb

@@ -14,10 +14,9 @@ module Rdkafka
     # then. Since the partitions count can only grow and should be same for all consumers and
     # producers, we can use a global cache as long as we ensure that updates only move up.
     #
+    # @return [Rdkafka::Producer::PartitionsCountCache]
     # @note It is critical to remember, that not all users may have statistics callbacks enabled,
     #   hence we should not make assumption that this cache is always updated from the stats.
-    #
-    # @return [Rdkafka::Producer::PartitionsCountCache]
     def self.partitions_count_cache
       @@partitions_count_cache
     end
@@ -64,12 +63,13 @@ module Rdkafka
     end
 
     # Sets alternative set of configuration details that can be set per topic
-    # @note It is not allowed to re-set the same topic config twice because of the underlying
-    #   librdkafka caching
+    #
     # @param topic [String] The topic name
     # @param config [Hash] config we want to use per topic basis
     # @param config_hash [Integer] hash of the config. We expect it here instead of computing it,
     #   because it is already computed during the retrieval attempt in the `#produce` flow.
+    # @note It is not allowed to re-set the same topic config twice because of the underlying
+    #   librdkafka caching
     def set_topic_config(topic, config, config_hash)
       # Ensure lock on topic reference just in case
       @native_kafka.with_inner do |inner|
@@ -125,8 +125,7 @@ module Rdkafka
     # Set a callback that will be called every time a message is successfully produced.
     # The callback is called with a {DeliveryReport} and {DeliveryHandle}
     #
-    # @param callback [Proc, #call] The callback
-    #
+    # @param callback [Proc, #call] callable object to handle delivery reports
     # @return [nil]
     def delivery_callback=(callback)
       raise TypeError.new("Callback has to be callable") unless callback.respond_to?(:call)
@@ -134,8 +133,11 @@ module Rdkafka
       @delivery_callback_arity = arity(callback)
     end
 
-    # Init transactions
-    # Run once per producer
+    # Initialize transactions for the producer
+    # Must be called once before any transactional operations
+    #
+    # @return [true] Returns true on success
+    # @raise [RdkafkaError] if initialization fails
     def init_transactions
       closed_producer_check(__method__)
 
@@ -146,6 +148,11 @@ module Rdkafka
       end
     end
 
+    # 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
     def begin_transaction
       closed_producer_check(__method__)
 
@@ -156,6 +163,11 @@ module Rdkafka
       end
     end
 
+    # Commit the current transaction
+    #
+    # @param timeout_ms [Integer] Timeout in milliseconds (-1 for infinite)
+    # @return [true] Returns true on success
+    # @raise [RdkafkaError] if committing the transaction fails
     def commit_transaction(timeout_ms = -1)
       closed_producer_check(__method__)
 
@@ -166,6 +178,11 @@ module Rdkafka
       end
     end
 
+    # Abort the current transaction
+    #
+    # @param timeout_ms [Integer] Timeout in milliseconds (-1 for infinite)
+    # @return [true] Returns true on success
+    # @raise [RdkafkaError] if aborting the transaction fails
     def abort_transaction(timeout_ms = -1)
       closed_producer_check(__method__)
 
@@ -181,7 +198,7 @@ module Rdkafka
     # @param tpl [Consumer::TopicPartitionList]
     # @param timeout_ms [Integer] offsets send timeout
     # @note Use **only** in the context of an active transaction
-    def send_offsets_to_transaction(consumer, tpl, timeout_ms = 5_000)
+    def send_offsets_to_transaction(consumer, tpl, timeout_ms = Defaults::PRODUCER_SEND_OFFSETS_TIMEOUT_MS)
       closed_producer_check(__method__)
 
       return if tpl.empty?
@@ -236,7 +253,7 @@ module Rdkafka
     #   should be no other errors.
     #
     # @note For `timed_out` we do not raise an error to keep it backwards compatible
-    def flush(timeout_ms=5_000)
+    def flush(timeout_ms=Defaults::PRODUCER_FLUSH_TIMEOUT_MS)
       closed_producer_check(__method__)
 
       error = @native_kafka.with_inner do |inner|
@@ -270,11 +287,37 @@ module Rdkafka
       end
 
       # Wait for the purge to affect everything
-      sleep(0.001) until flush(100)
+      sleep(Defaults::PRODUCER_PURGE_SLEEP_INTERVAL_MS / 1_000.0) until flush(Defaults::PRODUCER_PURGE_FLUSH_TIMEOUT_MS)
 
       true
     end
 
+    # Returns the number of messages and requests waiting to be sent to the broker as well as
+    # delivery reports queued for the application.
+    #
+    # This provides visibility into the producer's internal queue depth, useful for:
+    # - Monitoring producer backpressure
+    # - Implementing custom flow control
+    # - Debugging message delivery issues
+    # - Graceful shutdown logic (wait until queue is empty)
+    #
+    # @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
+    def queue_size
+      closed_producer_check(__method__)
+
+      @native_kafka.with_inner do |inner|
+        Rdkafka::Bindings.rd_kafka_outq_len(inner)
+      end
+    end
+
+    alias queue_length queue_size
+
     # Partition count for a given topic.
     #
     # @param topic [String] The topic name.
@@ -316,14 +359,15 @@ module Rdkafka
     # 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] The message's payload
-    # @param key [String, nil] The message's key
-    # @param partition [Integer,nil] Optional partition 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 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
     #

data/lib/rdkafka/version.rb

@@ -1,7 +1,10 @@
 # frozen_string_literal: true
 
 module Rdkafka
-  VERSION = "0.23.1.rc2"
-  LIBRDKAFKA_VERSION = "2.12.1"
-  LIBRDKAFKA_SOURCE_SHA256 = "ec103fa05cb0f251e375f6ea0b6112cfc9d0acd977dc5b69fdc54242ba38a16f"
+  # Current rdkafka-ruby gem version
+  VERSION = "0.24.0.rc1"
+  # Target librdkafka version to be used
+  LIBRDKAFKA_VERSION = "2.13.0"
+  # SHA256 hash of the librdkafka source tarball for verification
+  LIBRDKAFKA_SOURCE_SHA256 = "3bd351601d8ebcbc99b9a1316cae1b83b00edbcf9411c34287edf1791c507600"
 end

data/lib/rdkafka.rb

@@ -6,8 +6,10 @@ require "ffi"
 require "json"
 
 require "rdkafka/version"
+require "rdkafka/defaults"
 require "rdkafka/helpers/time"
 require "rdkafka/helpers/oauth"
+require "rdkafka/defaults"
 require "rdkafka/abstract_handle"
 require "rdkafka/admin"
 require "rdkafka/admin/create_topic_handle"

data/renovate.json

@@ -3,18 +3,11 @@
   "extends": [
     "config:recommended"
   ],
+  "minimumReleaseAge": "7 days",
   "github-actions": {
     "enabled": true,
     "pinDigests": true
   },
-  "packageRules": [
-    {
-      "matchManagers": [
-        "github-actions"
-      ],
-      "minimumReleaseAge": "7 days"
-    }
-  ],
   "customManagers": [
     {
       "customType": "regex",