waterdrop 2.8.16 → 2.10.0

data/lib/waterdrop/clients/rdkafka.rb

@@ -11,63 +11,185 @@ module WaterDrop
         # @param producer [WaterDrop::Producer] producer instance with its config, etc
         # @note We overwrite this that way, because we do not care
         def new(producer)
-          kafka_config = producer.config.kafka.to_h
           monitor = producer.config.monitor
+          kafka_config, statistics_enabled = prepare_statistics(
+            producer.config.kafka.to_h,
+            monitor
+          )
 
-          # When FD polling is enabled, we disable the native librdkafka polling thread
-          # and use our own Ruby-based poller instead
-          producer_options = { native_kafka_auto_start: false }
-
-          producer_options[:run_polling_thread] = false if producer.fd_polling?
+          client = build_rdkafka_client(producer, kafka_config)
 
-          client = ::Rdkafka::Config.new(kafka_config).producer(**producer_options)
+          register_instrumentation_callbacks(
+            producer,
+            client,
+            monitor,
+            statistics_enabled: statistics_enabled
+          )
 
-          # Register statistics runner for this particular type of callbacks
-          ::Karafka::Core::Instrumentation.statistics_callbacks.add(
+          # This callback is not global and is per client, thus we do not have to wrap it with a
+          # callbacks manager to make it work
+          client.delivery_callback = Instrumentation::Callbacks::Delivery.new(
             producer.id,
-            Instrumentation::Callbacks::Statistics.new(producer.id, client.name, monitor)
+            producer.transactional?,
+            monitor
           )
 
-          # Register error tracking callback
+          subscribe_oauth_listener(producer, monitor)
+          activate_client(producer, client, kafka_config)
+
+          client
+        end
+
+        private
+
+        # Decides whether librdkafka statistics should be enabled for this client and returns
+        # the (possibly mutated) kafka config together with the decision.
+        #
+        # When no one is subscribed to `statistics.emitted` at the time the underlying rdkafka
+        # client is being built, we force `statistics.interval.ms` to 0 regardless of user
+        # configuration. This prevents librdkafka from computing statistics periodically and
+        # saves a significant number of allocations on the Ruby side (no JSON parsing, no
+        # statistics hash materialization, no decorator work). Any listener subscribed after
+        # the client has been built will not receive `statistics.emitted` events because
+        # librdkafka never emits them in the first place — to use statistics, subscribe a
+        # listener BEFORE the first producer use.
+        #
+        # When statistics end up disabled (either because the user explicitly set the interval
+        # to 0, or because we forced it to 0 here), we freeze the statistics listener slot on
+        # the monitor. Any later subscription attempt raises instead of silently being a no-op,
+        # surfacing the timing mistake to the user immediately.
+        #
+        # @param kafka_config [Hash] kafka config hash taken from the producer config
+        # @param monitor [WaterDrop::Instrumentation::Monitor] per-producer monitor
+        # @return [Array] two-element array `[kafka_config, statistics_enabled]`. The returned
+        #   hash is a duped copy when we need to mutate the interval, so the producer's own
+        #   config hash is never touched.
+        def prepare_statistics(kafka_config, monitor)
+          statistics_enabled = kafka_config[:"statistics.interval.ms"].to_i.positive?
+
+          if statistics_enabled && !statistics_listener?(monitor)
+            kafka_config = kafka_config.dup
+            kafka_config[:"statistics.interval.ms"] = 0
+            statistics_enabled = false
+          end
+
+          monitor.freeze_statistics_listeners! unless statistics_enabled
+
+          [kafka_config, statistics_enabled]
+        end
+
+        # Instantiates the underlying rdkafka producer with the correct polling options. When
+        # FD polling is enabled, we disable librdkafka's native background polling thread and
+        # use our own Ruby-based poller instead.
+        #
+        # @param producer [WaterDrop::Producer]
+        # @param kafka_config [Hash]
+        # @return [::Rdkafka::Producer]
+        def build_rdkafka_client(producer, kafka_config)
+          producer_options = { native_kafka_auto_start: false }
+          producer_options[:run_polling_thread] = false if producer.fd_polling?
+
+          ::Rdkafka::Config.new(kafka_config).producer(**producer_options)
+        end
+
+        # Registers the global callbacks (statistics, error, oauth refresh) for this producer
+        # on the shared `Karafka::Core::Instrumentation` managers. The statistics callback is
+        # only registered when librdkafka is actually going to emit statistics — otherwise it
+        # would never fire and would only waste memory and a manager slot.
+        #
+        # @param producer [WaterDrop::Producer]
+        # @param client [::Rdkafka::Producer]
+        # @param monitor [WaterDrop::Instrumentation::Monitor]
+        # @param statistics_enabled [Boolean]
+        def register_instrumentation_callbacks(producer, client, monitor, statistics_enabled:)
+          if statistics_enabled
+            ::Karafka::Core::Instrumentation.statistics_callbacks.add(
+              producer.id,
+              Instrumentation::Callbacks::Statistics.new(
+                producer.id,
+                client.name,
+                monitor,
+                producer.config.statistics_decorator
+              )
+            )
+          end
+
           ::Karafka::Core::Instrumentation.error_callbacks.add(
             producer.id,
             Instrumentation::Callbacks::Error.new(producer.id, client.name, monitor)
           )
 
-          # Register oauth bearer refresh for this particular type of callbacks
           ::Karafka::Core::Instrumentation.oauthbearer_token_refresh_callbacks.add(
             producer.id,
             Instrumentation::Callbacks::OauthbearerTokenRefresh.new(client, monitor)
           )
+        end
 
-          # This callback is not global and is per client, thus we do not have to wrap it with a
-          # callbacks manager to make it work
-          client.delivery_callback = Instrumentation::Callbacks::Delivery.new(
-            producer.id,
-            producer.transactional?,
-            monitor
-          )
-
+        # Subscribes the oauth bearer token refresh listener to the monitor if one is configured.
+        #
+        # We need to subscribe it here because we want it to be ready before any producer
+        # callbacks run. In theory because the WaterDrop rdkafka producer is lazy loaded, the
+        # user would have enough time to subscribe it himself, but then it would not coop with
+        # auto-configuration coming from Karafka. The way it is done here, if it is configured
+        # it will be subscribed and if not, the user always can subscribe it himself as long as
+        # it is done prior to first usage.
+        #
+        # @param producer [WaterDrop::Producer]
+        # @param monitor [WaterDrop::Instrumentation::Monitor]
+        def subscribe_oauth_listener(producer, monitor)
           oauth_listener = producer.config.oauth.token_provider_listener
-          # We need to subscribe the oauth listener here because we want it to be ready before
-          # any producer callbacks run. In theory because WaterDrop rdkafka producer is lazy loaded
-          # we would have enough time to make user subscribe it himself, but then it would not
-          # coop with auto-configuration coming from Karafka. The way it is done below, if it is
-          # configured it will be subscribed and if not, user always can subscribe it himself as
-          # long as it is done prior to first usage
           monitor.subscribe(oauth_listener) if oauth_listener
+        end
 
+        # Transitions the freshly built client into an active state: starts the native side,
+        # registers it with our FD poller (when FD polling is enabled), and initializes
+        # transactions if the user configured a transactional id. Must run last so all
+        # callbacks are already wired up before the client goes live.
+        #
+        # If any step after `client.start` fails (most commonly `init_transactions` timing
+        # out when Kafka is unreachable), we must clean up everything that was already set up:
+        # unregister from the poller, remove the global instrumentation callbacks, and close
+        # the native client. Without this, each failed attempt leaks native threads, pipe
+        # file descriptors, and callback registry entries permanently.
+        #
+        # @param producer [WaterDrop::Producer]
+        # @param client [::Rdkafka::Producer]
+        # @param kafka_config [Hash]
+        def activate_client(producer, client, kafka_config)
           client.start
 
-          # Register with poller if FD polling is enabled
-          # Uses the producer's configured poller (custom or global singleton)
-          # This must happen after client.start to ensure the client is ready
+          # Register with poller if FD polling is enabled. Uses the producer's configured poller
+          # (custom or global singleton). This must happen after client.start to ensure the
+          # client is ready.
           producer.poller.register(producer, client) if producer.fd_polling?
 
-          # Switch to the transactional mode if user provided the transactional id
+          # Switch to transactional mode if user provided a transactional id
           client.init_transactions if kafka_config.key?(:"transactional.id")
+        rescue
+          # Unwind everything we set up before re-raising:
+          # 1. Unregister from poller (if we registered)
+          producer.poller.unregister(producer) if producer.fd_polling?
 
-          client
+          # 2. Remove global instrumentation callbacks so they don't accumulate
+          ::Karafka::Core::Instrumentation.statistics_callbacks.delete(producer.id)
+          ::Karafka::Core::Instrumentation.error_callbacks.delete(producer.id)
+          ::Karafka::Core::Instrumentation.oauthbearer_token_refresh_callbacks.delete(producer.id)
+
+          # 3. Close the native client to join its threads and release pipe FDs
+          client.close
+
+          raise
+        end
+
+        # Checks whether there is at least one subscriber to the `statistics.emitted` event on
+        # the per-producer monitor. We use this at client build time to decide whether to enable
+        # librdkafka statistics at all.
+        #
+        # @param monitor [WaterDrop::Instrumentation::Monitor] per-producer monitor
+        # @return [Boolean] true if any listener is registered for `statistics.emitted`
+        def statistics_listener?(monitor)
+          listeners = monitor.listeners["statistics.emitted"]
+          listeners && !listeners.empty?
         end
       end
     end

data/lib/waterdrop/config.rb

@@ -15,9 +15,9 @@ module WaterDrop
       "statistics.interval.ms": 5_000,
       # We set it to a value that is lower than `max_wait_timeout` to have a final verdict upon
       # sync delivery
-      "message.timeout.ms": 50_000,
+      "message.timeout.ms": 150_000,
       # Must be more or equal to `message.timeout.ms` defaults
-      "transaction.timeout.ms": 55_000,
+      "transaction.timeout.ms": 165_000,
       # Lowers latency. Default in newer librdkafka but we want to make sure it is shipped to
       # users despite what librdkafka they run on
       "socket.nagle.disable": true
@@ -53,7 +53,7 @@ module WaterDrop
     setting :max_payload_size, default: 1_000_012
     # option [Integer] Wait that long for the delivery report or raise an error if this takes
     #   longer than the timeout ms.
-    setting :max_wait_timeout, default: 60_000
+    setting :max_wait_timeout, default: 180_000
     # option [Boolean] should we upon detecting full librdkafka queue backoff and retry or should
     #   we raise an exception.
     #   When this is set to `true`, upon full queue, we won't raise an error. There will be error
@@ -116,6 +116,23 @@ module WaterDrop
     #   prevent overly aggressive disconnections.
     setting :idle_disconnect_timeout, default: 0
 
+    # option [Karafka::Core::Monitoring::StatisticsDecorator] decorator instance used to compute
+    #   deltas (_d) and freeze durations (_fd) on raw librdkafka statistics. The default is
+    #   pre-configured with `only_keys` covering keys used by the built-in Datadog metrics
+    #   listener and `excluded_keys` skipping subtrees not needed by producers (topics, broker
+    #   window stats). Users who need additional decorated keys or full decoration can provide
+    #   a custom decorator instance.
+    setting(
+      :statistics_decorator,
+      default: false,
+      constructor: lambda { |decorator|
+        decorator || ::Karafka::Core::Monitoring::StatisticsDecorator.new(
+          only_keys: %w[tx txretries txerrs rxerrs],
+          excluded_keys: %w[int_latency outbuf_latency rtt throttle req toppars topics]
+        )
+      }
+    )
+
     # option [Boolean] should we send messages. Setting this to false can be really useful when
     #   testing and or developing because when set to false, won't actually ping Kafka but will
     #   run all the validations, etc
@@ -143,9 +160,9 @@ module WaterDrop
     # Namespace for polling configuration
     setting :polling do
       # option [Symbol] Polling mode for handling producer callbacks
-      # :thread - uses librdkafka's native background polling threads (default)
-      # :fd - uses a single global Ruby thread with IO.select-based multiplexing
-      setting :mode, default: :thread
+      # :fd - uses a single global Ruby thread with IO.select-based multiplexing (default)
+      # :thread - uses librdkafka's native background polling threads
+      setting :mode, default: :fd
 
       # option [WaterDrop::Polling::Poller, nil] Custom poller instance for isolation
       # When nil (default), uses the global singleton poller shared by all FD-mode producers

data/lib/waterdrop/contracts/config.rb

@@ -33,10 +33,13 @@ module WaterDrop
       required(:non_reloadable_errors) do |val|
         val.is_a?(Array) && val.all?(Symbol)
       end
+
       required(:idle_disconnect_timeout) do |val|
         val.is_a?(Integer) && (val.zero? || val >= 30_000)
       end
 
+      required(:statistics_decorator) { |val| val.respond_to?(:call) }
+
       nested(:oauth) do
         required(:token_provider_listener) do |val|
           val == false || val.respond_to?(:on_oauthbearer_token_refresh)

data/lib/waterdrop/contracts/tombstone.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+module WaterDrop
+  module Contracts
+    # Contract for validating tombstone-specific message requirements.
+    # Tombstones require a non-nil key and an explicit partition.
+    #
+    # @note Topic, headers, and other standard message attributes are validated separately
+    #   by the {Message} contract during the produce delegation flow.
+    class Tombstone < ::Karafka::Core::Contractable::Contract
+      configure do |config|
+        config.error_messages = YAML.safe_load_file(
+          File.join(WaterDrop.gem_root, "config", "locales", "errors.yml")
+        ).fetch("en").fetch("validations").fetch("tombstone")
+      end
+
+      required(:key) { |val| val.is_a?(String) && !val.empty? }
+      required(:partition) { |val| val.is_a?(Integer) && val >= 0 }
+    end
+  end
+end

data/lib/waterdrop/errors.rb

@@ -59,6 +59,13 @@ module WaterDrop
     # Raised when an error occurs in the polling loop
     PollerError = Class.new(BaseError)
 
+    # Raised when trying to subscribe to `statistics.emitted` after the underlying rdkafka client
+    # has been built without any listener present at build time. In that case, librdkafka
+    # statistics are disabled entirely for performance, and late subscriptions would silently
+    # receive nothing. To fix: subscribe the listener BEFORE first producer use (i.e. before the
+    # underlying client is lazily initialized).
+    StatisticsNotEnabledError = Class.new(BaseError)
+
     # Raised when during messages producing something bad happened inline
     class ProduceManyError < ProduceError
       attr_reader :dispatched

data/lib/waterdrop/instrumentation/callbacks/statistics.rb

@@ -13,11 +13,13 @@ module WaterDrop
         # @param producer_id [String]
         # @param client_name [String] rdkafka client name
         # @param monitor [WaterDrop::Instrumentation::Monitor] monitor we are using
-        def initialize(producer_id, client_name, monitor)
+        # @param statistics_decorator [Karafka::Core::Monitoring::StatisticsDecorator] decorator
+        #   instance to use for computing deltas and freeze durations on raw librdkafka statistics
+        def initialize(producer_id, client_name, monitor, statistics_decorator)
           @producer_id = producer_id
           @client_name = client_name
           @monitor = monitor
-          @statistics_decorator = ::Karafka::Core::Monitoring::StatisticsDecorator.new
+          @statistics_decorator = statistics_decorator
         end
 
         # Emits decorated statistics to the monitor

data/lib/waterdrop/instrumentation/monitor.rb

@@ -6,6 +6,15 @@ module WaterDrop
     # By default uses our internal notifications bus but can be used with
     # `ActiveSupport::Notifications` as well
     class Monitor < ::Karafka::Core::Monitoring::Monitor
+      # Event name for librdkafka statistics emissions
+      STATISTICS_EVENT = "statistics.emitted"
+
+      # Method name a listener object must implement in order to receive
+      # `statistics.emitted` events via object-based subscription
+      STATISTICS_LISTENER_METHOD = :on_statistics_emitted
+
+      private_constant :STATISTICS_EVENT, :STATISTICS_LISTENER_METHOD
+
       # @param notifications_bus [Object] either our internal notifications bus or
       #   `ActiveSupport::Notifications`
       # @param namespace [String, nil] namespace for events or nil if no namespace
@@ -14,6 +23,58 @@ module WaterDrop
         namespace = nil
       )
         super
+        @statistics_listeners_frozen = false
+      end
+
+      # Marks this monitor as no longer accepting new subscriptions to `statistics.emitted`.
+      # Called by the rdkafka client builder when it decides to leave librdkafka statistics
+      # disabled (because no listener was present at build time). Any subsequent attempt to
+      # subscribe to `statistics.emitted` — either via a block or via a listener object that
+      # responds to `on_statistics_emitted` — will raise
+      # `WaterDrop::Errors::StatisticsNotEnabledError` instead of silently doing nothing.
+      def freeze_statistics_listeners!
+        @statistics_listeners_frozen = true
+      end
+
+      # Subscribes to the notifications bus, raising if the user tries to subscribe to
+      # `statistics.emitted` after statistics have been disabled at client build time. This
+      # prevents the "silent nothing" pitfall where a user expects statistics but no events
+      # ever arrive because librdkafka statistics were turned off entirely.
+      #
+      # @param event_id_or_listener [String, Symbol, Object] event id (with block) or listener
+      # @param block [Proc, nil] handler block when subscribing to a named event
+      # @raise [WaterDrop::Errors::StatisticsNotEnabledError] when the subscription targets
+      #   `statistics.emitted` and this monitor has been frozen for statistics
+      def subscribe(event_id_or_listener, &block)
+        if @statistics_listeners_frozen && targets_statistics?(event_id_or_listener, block)
+          raise Errors::StatisticsNotEnabledError, <<~MSG.tr("\n", " ").strip
+            Cannot subscribe to `statistics.emitted` after the producer has been connected.
+            Statistics are disabled because no listener was subscribed before the underlying
+            rdkafka client was built, so librdkafka is not emitting statistics at all.
+            Subscribe your listener BEFORE the first producer use (before the underlying
+            client is lazily initialized), or explicitly keep statistics enabled by leaving
+            a listener in place at build time.
+          MSG
+        end
+
+        super
+      end
+
+      private
+
+      # Determines whether a subscription call targets `statistics.emitted`. Handles both
+      # block-based subscription (where the first argument is the event id string) and
+      # listener-object subscription (where the listener responds to `on_statistics_emitted`).
+      #
+      # @param event_id_or_listener [String, Symbol, Object]
+      # @param block [Proc, nil]
+      # @return [Boolean]
+      def targets_statistics?(event_id_or_listener, block)
+        if block
+          event_id_or_listener.to_s == STATISTICS_EVENT
+        else
+          event_id_or_listener.respond_to?(STATISTICS_LISTENER_METHOD)
+        end
       end
     end
   end

data/lib/waterdrop/polling/latch.rb

@@ -18,6 +18,7 @@ module WaterDrop
     # This ensures the producer is fully drained and removed from the poller
     # before returning control to the caller, preventing race conditions.
     class Latch
+      # Initializes a new latch in the unreleased state.
       def initialize
         @mutex = Mutex.new
         @cv = ConditionVariable.new

data/lib/waterdrop/polling/poller.rb

@@ -47,6 +47,8 @@ module WaterDrop
       # @return [Integer] unique identifier for this poller instance
       attr_reader :id
 
+      # Initializes an empty poller with no registered producers. The background thread is
+      # not started until the first producer is registered.
       def initialize
         @id = self.class.next_id
         @mutex = Mutex.new
@@ -142,6 +144,8 @@ module WaterDrop
       # This matches the threaded polling behavior which drains without timeout
       # @param producer [WaterDrop::Producer] the producer instance
       def unregister(producer)
+        ensure_same_process!
+
         state, thread = @mutex.synchronize { [@producers[producer.id], @thread] }
 
         return unless state

data/lib/waterdrop/producer/tombstone.rb

@@ -0,0 +1,78 @@
+# frozen_string_literal: true
+
+module WaterDrop
+  class Producer
+    # Component for tombstone producer operations
+    #
+    # Tombstone records are Kafka messages with a nil payload, used to signal deletion of a key
+    # in compacted topics. This module provides a dedicated API so users don't have to manually
+    # construct `produce_*(topic:, key:, payload: nil, ...)` calls.
+    module Tombstone
+      # Produces a tombstone message to Kafka and waits for it to be delivered
+      #
+      # @param message [Hash] hash with at least `:topic`, `:key`, and `:partition` keys.
+      #   `:payload` is not accepted — it will be silently removed if present.
+      #
+      # @return [Rdkafka::Producer::DeliveryReport] delivery report
+      #
+      # @raise [Errors::MessageInvalidError] When `:key` or `:partition` is missing
+      def tombstone_sync(message)
+        produce_sync(prepare_tombstone(message))
+      end
+
+      # Produces a tombstone message to Kafka and does not wait for results
+      #
+      # @param message [Hash] hash with at least `:topic`, `:key`, and `:partition` keys.
+      #   `:payload` is not accepted — it will be silently removed if present.
+      #
+      # @return [Rdkafka::Producer::DeliveryHandle] delivery handle
+      #
+      # @raise [Errors::MessageInvalidError] When `:key` or `:partition` is missing
+      def tombstone_async(message)
+        produce_async(prepare_tombstone(message))
+      end
+
+      # Produces many tombstone messages to Kafka and waits for them to be delivered
+      #
+      # @param messages [Array<Hash>] array of hashes, each with `:topic`, `:key`, and
+      #   `:partition` keys
+      #
+      # @return [Array<Rdkafka::Producer::DeliveryHandle>] delivery handles
+      #
+      # @raise [Errors::MessageInvalidError] When any message is missing `:key` or `:partition`
+      def tombstone_many_sync(messages)
+        produce_many_sync(messages.map { |message| prepare_tombstone(message) })
+      end
+
+      # Produces many tombstone messages to Kafka and does not wait for them to be delivered
+      #
+      # @param messages [Array<Hash>] array of hashes, each with `:topic`, `:key`, and
+      #   `:partition` keys
+      #
+      # @return [Array<Rdkafka::Producer::DeliveryHandle>] delivery handles
+      #
+      # @raise [Errors::MessageInvalidError] When any message is missing `:key` or `:partition`
+      def tombstone_many_async(messages)
+        produce_many_async(messages.map { |message| prepare_tombstone(message) })
+      end
+
+      private
+
+      # Validates and prepares a tombstone message by ensuring required keys are present
+      # and setting payload to nil
+      #
+      # @param message [Hash] the original message hash
+      # @return [Hash] a new message hash with payload set to nil
+      # @raise [Errors::MessageInvalidError] when key or partition is missing
+      def prepare_tombstone(message)
+        message = message.dup
+        message.delete(:payload)
+        message[:payload] = nil
+
+        Contracts::Tombstone.new.validate!(message, Errors::MessageInvalidError)
+
+        message
+      end
+    end
+  end
+end

data/lib/waterdrop/producer/variant.rb

@@ -71,6 +71,7 @@ module WaterDrop
         Async,
         Buffer,
         Sync,
+        Tombstone,
         Transactions
       ].each do |scope|
         scope.instance_methods(false).each do |method_name|
@@ -81,7 +82,7 @@ module WaterDrop
           #
           #     @producer.produce_async(*args, &block)
           #   ensure
-          #     ref[@producer.id] = nil
+          #     ref.delete(@producer.id)
           #   end
           class_eval <<-RUBY, __FILE__, __LINE__ + 1
             def #{method_name}(*args, &block)
@@ -90,7 +91,7 @@ module WaterDrop
 
               @producer.#{method_name}(*args, &block)
             ensure
-              ref[@producer.id] = nil
+              ref.delete(@producer.id)
             end
           RUBY
         end

data/lib/waterdrop/producer.rb

@@ -7,6 +7,7 @@ module WaterDrop
     include Sync
     include Async
     include Buffer
+    include Tombstone
     include Transactions
     include Idempotence
     include ClassMonitor

data/lib/waterdrop/version.rb

@@ -3,5 +3,5 @@
 # WaterDrop library
 module WaterDrop
   # Current WaterDrop version
-  VERSION = "2.8.16"
+  VERSION = "2.10.0"
 end

data/package-lock.json

@@ -217,9 +217,9 @@
       }
     },
     "node_modules/picomatch": {
-      "version": "2.3.1",
-      "resolved": "https://registry.npmjs.org/picomatch/-/picomatch-2.3.1.tgz",
-      "integrity": "sha512-JU3teHTNjmE2VCGFzuY8EXzCDVwEqB2a8fsIvwaStHhAWJEeVd1o1QD80CU6+ZdEXXSLbSsuLwJjkCBWqRQUVA==",
+      "version": "2.3.2",
+      "resolved": "https://registry.npmjs.org/picomatch/-/picomatch-2.3.2.tgz",
+      "integrity": "sha512-V7+vQEJ06Z+c5tSye8S+nHUfI51xoXIXjHQ99cQtKUkQqqO1kO/KCJUfZXuB47h/YBlDhah2H3hdUGXn8ie0oA==",
       "dev": true,
       "license": "MIT",
       "engines": {

data/renovate.json

@@ -8,7 +8,7 @@
     "Gemfile",
     "Gemfile.lint",
     "waterdrop.gemspec",
-    "spec/integrations/**/Gemfile",
+    "test/integrations/**/Gemfile",
     ".github/workflows/**",
     "docker-compose*.yml",
     "package.json"
@@ -28,7 +28,7 @@
     },
     {
       "matchFileNames": [
-        "spec/integrations/**/Gemfile"
+        "test/integrations/**/Gemfile"
       ],
       "groupName": "integration test dependencies",
       "commitMessageTopic": "integration test dependencies"
@@ -45,5 +45,8 @@
   "minimumReleaseAge": "7 days",
   "labels": [
     "dependencies"
-  ]
+  ],
+  "lockFileMaintenance": {
+    "enabled": true
+  }
 }

data/waterdrop.gemspec

@@ -16,13 +16,13 @@ Gem::Specification.new do |spec|
   spec.description = spec.summary
   spec.licenses = %w[LGPL-3.0-only Commercial]
 
-  spec.add_dependency "karafka-core", ">= 2.4.9", "< 3.0.0"
+  spec.add_dependency "karafka-core", ">= 2.5.12", "< 3.0.0"
   spec.add_dependency "karafka-rdkafka", ">= 0.24.0"
   spec.add_dependency "zeitwerk", "~> 2.3"
 
   spec.required_ruby_version = ">= 3.2.0"
 
-  spec.files = `git ls-files -z`.split("\x0").reject { |f| f.match(%r{^(spec)/}) }
+  spec.files = `git ls-files -z`.split("\x0").reject { |f| f.match?(%r{^(spec|test|\.github|log)/}) }
   spec.executables = []
   spec.require_paths = %w[lib]