waterdrop 2.4.10 → 2.5.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 1ea085fa5ca2adea3def9f04dc8ec1d228aea2cb073ec9b41dc10efd08f2fcc4
-  data.tar.gz: b830060cefaf8fef9e5aa68c52534300146f05eb17f151ef720eaad934208bdc
+  metadata.gz: 8aa4c6d8e6d5364a4a1a93739a0292410d664df16f7d93545bb478b5659ee443
+  data.tar.gz: 2bf8a36f8332be75eef108b90b2179ecc18f7301750f551eadce9d90eec6c5a9
 SHA512:
-  metadata.gz: 5ab0511f78ef3f1abc12c85334880df782e375ff23a14a2304b97ec78beea81a04659ec17b60a135f1e94e545463531b9202ebbc59c0273d7094b7d40b64c9a4
-  data.tar.gz: c1a94e01292ff4a4d4e18ae7d88714b71d68f2e36cec9dd497087d0f359e65b9a94b77d66977e3a4e233152ae657bb0d83b1421fe0409e52d419efe3e163b813
+  metadata.gz: 35269366d659f9dcada5fafd5120f2434784c29417c021a6d78fad722496c37acde6617c4e4e6fee3132052248e5b935c958cb45a1113c8510d995cfd6136ccb
+  data.tar.gz: 8ff77a6a0c61118cf5dcad89f7d7414c510107bb559683fd8b0c133798c686cf6bbf5eef95fb14ecb5bf5762354148eb545b6835e597730457125c69cd996a41

data/.ruby-version

@@ -1 +1 @@
-3.2.0
+3.2.1

data/CHANGELOG.md

@@ -1,5 +1,40 @@
 # WaterDrop changelog
 
+## 2.5.0 (2023-03-04)
+- [Feature] Pipe **all** the errors including synchronous errors via the `error.occurred`.
+- [Improvement] Pipe delivery errors that occurred not via the error callback using the `error.occurred` channel.
+- [Improvement] Introduce `WaterDrop::Errors::ProduceError` and `WaterDrop::Errors::ProduceManyError` for any inline raised errors that occur. You can get the original error by using the `#cause`.
+- [Improvement] Include `#dispatched` messages handler in the `WaterDrop::Errors::ProduceManyError` error, to be able to understand which of the messages were delegated to `librdkafka` prior to the failure.
+- [Maintenance] Remove the `WaterDrop::Errors::FlushFailureError` in favour of correct error that occurred to unify the error handling.
+- [Maintenance] Rename `Datadog::Listener` to `Datadog::MetricsListener` to align with Karafka (#329).
+- [Fix] Do **not** flush when there is no data to flush in the internal buffer.
+- [Fix] Wait on the final data flush for short-lived producers to make sure, that the message is actually dispatched by `librdkafka` or timeout.
+
+### Upgrade notes
+
+Please note, this **is** a **breaking** release, hence `2.5.0`.
+
+1. If you used to catch `WaterDrop::Errors::FlushFailureError` now you need to catch `WaterDrop::Errors::ProduceError`. `WaterDrop::Errors::ProduceManyError` is based on the `ProduceError`, hence it should be enough.
+2. Prior to `2.5.0` there was always a chance of partial dispatches via `produce_many_` methods. Now you can get the info on all the errors via `error.occurred`.
+3. Inline `Rdkafka::RdkafkaError` are now re-raised via `WaterDrop::Errors::ProduceError` and available under `#cause`. Async `Rdkafka::RdkafkaError` errors are still directly available and you can differentiate between errors using the event `type`.
+4. If you are using the Datadog listener, you need to:
+
+```ruby
+# Replace require:
+require 'waterdrop/instrumentation/vendors/datadog/listener'
+# With
+require 'waterdrop/instrumentation/vendors/datadog/metrics_listener'
+
+# Replace references of
+::WaterDrop::Instrumentation::Vendors::Datadog::Listener.new
+# With
+::WaterDrop::Instrumentation::Vendors::Datadog::MetricsListener.new
+```
+
+## 2.4.11 (2023-02-24)
+- Replace the local rspec locator with generalized core one.
+- Make `::WaterDrop::Instrumentation::Notifications::EVENTS` list public for anyone wanting to re-bind those into a different notification bus.
+
 ## 2.4.10 (2023-01-30)
 - Include `caller` in the error instrumentation to align with Karafka.
 

data/Gemfile.lock

@@ -1,8 +1,8 @@
 PATH
   remote: .
   specs:
-    waterdrop (2.4.10)
-      karafka-core (>= 2.0.9, < 3.0.0)
+    waterdrop (2.5.0)
+      karafka-core (>= 2.0.12, < 3.0.0)
       zeitwerk (~> 2.3)
 
 GEM
@@ -14,7 +14,7 @@ GEM
       minitest (>= 5.1)
       tzinfo (~> 2.0)
     byebug (11.1.3)
-    concurrent-ruby (1.2.0)
+    concurrent-ruby (1.2.2)
     diff-lcs (1.5.0)
     docile (1.4.0)
     factory_bot (6.2.1)
@@ -22,10 +22,10 @@ GEM
     ffi (1.15.5)
     i18n (1.12.0)
       concurrent-ruby (~> 1.0)
-    karafka-core (2.0.9)
+    karafka-core (2.0.12)
       concurrent-ruby (>= 1.1)
-      karafka-rdkafka (>= 0.12)
-    karafka-rdkafka (0.12.0)
+      karafka-rdkafka (>= 0.12.1)
+    karafka-rdkafka (0.12.1)
       ffi (~> 1.15)
       mini_portile2 (~> 2.6)
       rake (> 12)
@@ -36,7 +36,7 @@ GEM
       rspec-core (~> 3.12.0)
       rspec-expectations (~> 3.12.0)
       rspec-mocks (~> 3.12.0)
-    rspec-core (3.12.0)
+    rspec-core (3.12.1)
       rspec-support (~> 3.12.0)
     rspec-expectations (3.12.2)
       diff-lcs (>= 1.2.0, < 2.0)
@@ -53,7 +53,7 @@ GEM
     simplecov_json_formatter (0.1.4)
     tzinfo (2.0.6)
       concurrent-ruby (~> 1.0)
-    zeitwerk (2.6.6)
+    zeitwerk (2.6.7)
 
 PLATFORMS
   arm64-darwin-21
@@ -67,4 +67,4 @@ DEPENDENCIES
   waterdrop!
 
 BUNDLED WITH
-   2.4.5
+   2.4.7

data/README.md

@@ -303,7 +303,7 @@ producer.produce_async(topic: 'events', payload: 'data')
 producer.close
 ```
 
-See the `WaterDrop::Instrumentation::Monitor::EVENTS` for the list of all the supported events.
+See the `WaterDrop::Instrumentation::Notifications::EVENTS` for the list of all the supported events.
 
 ### Usage statistics
 
@@ -387,6 +387,8 @@ end
 # WaterDrop error occurred: Local: Broker transport failure (transport)
 ```
 
+**Note:** `error.occurred` will also include any errors originating from `librdkafka` for synchronous operations, including those that are raised back to the end user.
+
 ### Acknowledgment notifications
 
 WaterDrop allows you to listen to Kafka messages' acknowledgment events. This will enable you to monitor deliveries of messages from WaterDrop even when using asynchronous dispatch methods.
@@ -423,7 +425,7 @@ WaterDrop comes with (optional) full Datadog and StatsD integration that you can
 ```ruby
 # require datadog/statsd and the listener as it is not loaded by default
 require 'datadog/statsd'
-require 'waterdrop/instrumentation/vendors/datadog/listener'
+require 'waterdrop/instrumentation/vendors/datadog/metrics_listener'
 
 # initialize your producer with statistics.interval.ms enabled so the metrics are published
 producer = WaterDrop::Producer.new do |config|
@@ -435,7 +437,7 @@ producer = WaterDrop::Producer.new do |config|
 end
 
 # initialize the listener with statsd client
-listener = ::WaterDrop::Instrumentation::Vendors::Datadog::Listener.new do |config|
+listener = ::WaterDrop::Instrumentation::Vendors::Datadog::MetricsListener.new do |config|
   config.client = Datadog::Statsd.new('localhost', 8125)
   # Publish host as a tag alongside the rest of tags
   config.default_tags = ["host:#{Socket.gethostname}"]

data/lib/waterdrop/errors.rb

@@ -29,15 +29,18 @@ module WaterDrop
     # contact us as it is an error.
     StatusInvalidError = Class.new(BaseError)
 
-    # Raised when during messages flushing something bad happened
-    class FlushFailureError < BaseError
-      attr_reader :dispatched_messages
+    # Raised when there is an inline error during single message produce operations
+    ProduceError = Class.new(BaseError)
 
-      # @param dispatched_messages [Array<Rdkafka::Producer::DeliveryHandle>] handlers of the
+    # Raised when during messages producing something bad happened inline
+    class ProduceManyError < ProduceError
+      attr_reader :dispatched
+
+      # @param dispatched [Array<Rdkafka::Producer::DeliveryHandle>] handlers of the
       #   messages that we've dispatched
-      def initialize(dispatched_messages)
+      def initialize(dispatched)
         super()
-        @dispatched_messages = dispatched_messages
+        @dispatched = dispatched
       end
     end
   end

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

@@ -17,6 +17,30 @@ module WaterDrop
         # Emits delivery details to the monitor
         # @param delivery_report [Rdkafka::Producer::DeliveryReport] delivery report
         def call(delivery_report)
+          if delivery_report.error.to_i.positive?
+            instrument_error(delivery_report)
+          else
+            instrument_acknowledged(delivery_report)
+          end
+        end
+
+        private
+
+        # @param delivery_report [Rdkafka::Producer::DeliveryReport] delivery report
+        def instrument_error(delivery_report)
+          @monitor.instrument(
+            'error.occurred',
+            caller: self,
+            error: ::Rdkafka::RdkafkaError.new(delivery_report.error),
+            producer_id: @producer_id,
+            offset: delivery_report.offset,
+            partition: delivery_report.partition,
+            type: 'librdkafka.dispatch_error'
+          )
+        end
+
+        # @param delivery_report [Rdkafka::Producer::DeliveryReport] delivery report
+        def instrument_acknowledged(delivery_report)
           @monitor.instrument(
             'message.acknowledged',
             producer_id: @producer_id,

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

@@ -18,6 +18,8 @@ module WaterDrop
         # @param client_name [String] rdkafka client name
         # @param error [Rdkafka::Error] error that occurred
         # @note It will only instrument on errors of the client of our producer
+        # @note When there is a particular message produce error (not internal error), the error
+        #   is shipped via the delivery callback, not via error callback.
         def call(client_name, error)
           # Emit only errors related to our client
           # Same as with statistics (mor explanation there)

data/lib/waterdrop/instrumentation/notifications.rb

@@ -26,8 +26,6 @@ module WaterDrop
         error.occurred
       ].freeze
 
-      private_constant :EVENTS
-
       # @return [WaterDrop::Instrumentation::Monitor] monitor instance for system instrumentation
       def initialize
         super

data/lib/waterdrop/instrumentation/vendors/datadog/{listener.rb → metrics_listener.rb}

@@ -10,7 +10,7 @@ module WaterDrop
         # and/or Datadog
         #
         # @note You need to setup the `dogstatsd-ruby` client and assign it
-        class Listener
+        class MetricsListener
           include ::Karafka::Core::Configurable
           extend Forwardable
 

data/lib/waterdrop/patches/rdkafka/client.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+module WaterDrop
+  module Patches
+    module Rdkafka
+      # Patches for the producer client
+      module Client
+        # @param _object_id [nil] rdkafka API compatibility argument
+        # @param timeout_ms [Integer] final flush timeout in ms
+        def close(_object_id = nil, timeout_ms = 5_000)
+          return unless @native
+
+          # Indicate to polling thread that we're closing
+          @polling_thread[:closing] = true
+          # Wait for the polling thread to finish up
+          @polling_thread.join
+
+          ::Rdkafka::Bindings.rd_kafka_flush(@native, timeout_ms)
+          ::Rdkafka::Bindings.rd_kafka_destroy(@native)
+
+          @native = nil
+        end
+      end
+    end
+  end
+end
+
+::Rdkafka::Bindings.attach_function(
+  :rd_kafka_flush,
+  %i[pointer int],
+  :void
+)
+
+Rdkafka::Producer::Client.prepend WaterDrop::Patches::Rdkafka::Client

data/lib/waterdrop/patches/rdkafka/producer.rb

@@ -70,6 +70,14 @@ module WaterDrop
 
           @_inner_kafka
         end
+
+        # Closes our librdkafka instance with the flush patch
+        # @param timeout_ms [Integer] flush timeout
+        def close(timeout_ms = 5_000)
+          ObjectSpace.undefine_finalizer(self)
+
+          @client.close(nil, timeout_ms)
+        end
       end
     end
   end

data/lib/waterdrop/producer/async.rb

@@ -23,7 +23,19 @@ module WaterDrop
           'message.produced_async',
           producer_id: id,
           message: message
-        ) { client.produce(**message) }
+        ) { produce(message) }
+      rescue *SUPPORTED_FLOW_ERRORS
+        re_raised = Errors::ProduceError.new
+
+        @monitor.instrument(
+          'error.occurred',
+          producer_id: id,
+          message: message,
+          error: re_raised,
+          type: 'message.produce_async'
+        )
+
+        raise re_raised
       end
 
       # Produces many messages to Kafka and does not wait for them to be delivered
@@ -39,6 +51,7 @@ module WaterDrop
       def produce_many_async(messages)
         ensure_active!
 
+        dispatched = []
         messages = middleware.run_many(messages)
         messages.each { |message| validate_message!(message) }
 
@@ -47,8 +60,25 @@ module WaterDrop
           producer_id: id,
           messages: messages
         ) do
-          messages.map { |message| client.produce(**message) }
+          messages.each do |message|
+            dispatched << produce(message)
+          end
+
+          dispatched
         end
+      rescue *SUPPORTED_FLOW_ERRORS
+        re_raised = Errors::ProduceManyError.new(dispatched)
+
+        @monitor.instrument(
+          'error.occurred',
+          producer_id: id,
+          messages: messages,
+          dispatched: dispatched,
+          error: re_raised,
+          type: 'messages.produce_many_async'
+        )
+
+        raise re_raised
       end
     end
   end

data/lib/waterdrop/producer/buffer.rb

@@ -4,14 +4,6 @@ module WaterDrop
   class Producer
     # Component for buffered operations
     module Buffer
-      # Exceptions we catch when dispatching messages from a buffer
-      RESCUED_ERRORS = [
-        Rdkafka::RdkafkaError,
-        Rdkafka::Producer::DeliveryHandle::WaitTimeoutError
-      ].freeze
-
-      private_constant :RESCUED_ERRORS
-
       # Adds given message into the internal producer buffer without flushing it to Kafka
       #
       # @param message [Hash] hash that complies with the {Contracts::Message} contract
@@ -85,39 +77,21 @@ module WaterDrop
       # @param sync [Boolean] should it flush in a sync way
       # @return [Array<Rdkafka::Producer::DeliveryHandle, Rdkafka::Producer::DeliveryReport>]
       #   delivery handles for async or delivery reports for sync
-      # @raise [Errors::FlushFailureError] when there was a failure in flushing
+      # @raise [Errors::ProduceManyError] when there was a failure in flushing
       # @note We use this method underneath to provide a different instrumentation for sync and
       #   async flushing within the public API
       def flush(sync)
         data_for_dispatch = nil
-        dispatched = []
 
         @buffer_mutex.synchronize do
           data_for_dispatch = @messages
           @messages = Concurrent::Array.new
         end
 
-        dispatched = data_for_dispatch.map { |message| client.produce(**message) }
-
-        return dispatched unless sync
-
-        dispatched.map do |handler|
-          handler.wait(
-            max_wait_timeout: @config.max_wait_timeout,
-            wait_timeout: @config.wait_timeout
-          )
-        end
-      rescue *RESCUED_ERRORS => e
-        @monitor.instrument(
-          'error.occurred',
-          caller: self,
-          error: e,
-          producer_id: id,
-          dispatched: dispatched,
-          type: sync ? 'buffer.flushed_sync.error' : 'buffer.flush_async.error'
-        )
+        # Do nothing if nothing to flush
+        return data_for_dispatch if data_for_dispatch.empty?
 
-        raise Errors::FlushFailureError.new(dispatched)
+        sync ? produce_many_sync(data_for_dispatch) : produce_many_async(data_for_dispatch)
       end
     end
   end

data/lib/waterdrop/producer/sync.rb

@@ -26,13 +26,20 @@ module WaterDrop
           producer_id: id,
           message: message
         ) do
-          client
-            .produce(**message)
-            .wait(
-              max_wait_timeout: @config.max_wait_timeout,
-              wait_timeout: @config.wait_timeout
-            )
+          wait(produce(message))
         end
+      rescue *SUPPORTED_FLOW_ERRORS
+        re_raised = Errors::ProduceError.new
+
+        @monitor.instrument(
+          'error.occurred',
+          producer_id: id,
+          message: message,
+          error: re_raised,
+          type: 'message.produce_sync'
+        )
+
+        raise re_raised
       end
 
       # Produces many messages to Kafka and waits for them to be delivered
@@ -48,21 +55,37 @@ module WaterDrop
       # @raise [Errors::MessageInvalidError] When any of the provided messages details are invalid
       #   and the message could not be sent to Kafka
       def produce_many_sync(messages)
-        ensure_active!
+        ensure_active! unless @closing_thread_id && @closing_thread_id == Thread.current.object_id
 
         messages = middleware.run_many(messages)
         messages.each { |message| validate_message!(message) }
 
+        dispatched = []
+
         @monitor.instrument('messages.produced_sync', producer_id: id, messages: messages) do
-          messages
-            .map { |message| client.produce(**message) }
-            .map! do |handler|
-              handler.wait(
-                max_wait_timeout: @config.max_wait_timeout,
-                wait_timeout: @config.wait_timeout
-              )
-            end
+          messages.each do |message|
+            dispatched << produce(message)
+          end
+
+          dispatched.map! do |handler|
+            wait(handler)
+          end
+
+          dispatched
         end
+      rescue *SUPPORTED_FLOW_ERRORS
+        re_raised = Errors::ProduceManyError.new(dispatched)
+
+        @monitor.instrument(
+          'error.occurred',
+          producer_id: id,
+          messages: messages,
+          dispatched: dispatched,
+          error: re_raised,
+          type: 'messages.produce_many_sync'
+        )
+
+        raise re_raised
       end
     end
   end

data/lib/waterdrop/producer.rb

@@ -8,6 +8,14 @@ module WaterDrop
     include Async
     include Buffer
 
+    # Which of the inline flow errors do we want to intercept and re-bind
+    SUPPORTED_FLOW_ERRORS = [
+      Rdkafka::RdkafkaError,
+      Rdkafka::Producer::DeliveryHandle::WaitTimeoutError
+    ].freeze
+
+    private_constant :SUPPORTED_FLOW_ERRORS
+
     def_delegators :config, :middleware
 
     # @return [String] uuid of the current producer
@@ -117,6 +125,10 @@ module WaterDrop
           # This should be used only in case a producer was not closed properly and forgotten
           ObjectSpace.undefine_finalizer(id)
 
+          # We save this thread id because we need to bypass the activity verification on the
+          # producer for final flush of buffers.
+          @closing_thread_id = Thread.current.object_id
+
           # Flush has its own buffer mutex but even if it is blocked, flushing can still happen
           # as we close the client after the flushing (even if blocked by the mutex)
           flush(true)
@@ -125,7 +137,7 @@ module WaterDrop
           # It is safe to run it several times but not exactly the same moment
           # We also mark it as closed only if it was connected, if not, it would trigger a new
           # connection that anyhow would be immediately closed
-          client.close if @client
+          client.close(@config.max_wait_timeout) if @client
 
           # Remove callbacks runners that were registered
           ::Karafka::Core::Instrumentation.statistics_callbacks.delete(@id)
@@ -155,5 +167,22 @@ module WaterDrop
     def validate_message!(message)
       @contract.validate!(message, Errors::MessageInvalidError)
     end
+
+    # Runs the client produce method with a given message
+    #
+    # @param message [Hash] message we want to send
+    def produce(message)
+      client.produce(**message)
+    end
+
+    # Waits on a given handler
+    #
+    # @param handler [Rdkafka::Producer::DeliveryHandle]
+    def wait(handler)
+      handler.wait(
+        max_wait_timeout: @config.max_wait_timeout,
+        wait_timeout: @config.wait_timeout
+      )
+    end
   end
 end

data/lib/waterdrop/version.rb

@@ -3,5 +3,5 @@
 # WaterDrop library
 module WaterDrop
   # Current WaterDrop version
-  VERSION = '2.4.10'
+  VERSION = '2.5.0'
 end

data/waterdrop.gemspec

@@ -16,7 +16,7 @@ Gem::Specification.new do |spec|
   spec.description   = spec.summary
   spec.license       = 'MIT'
 
-  spec.add_dependency 'karafka-core', '>= 2.0.9', '< 3.0.0'
+  spec.add_dependency 'karafka-core', '>= 2.0.12', '< 3.0.0'
   spec.add_dependency 'zeitwerk', '~> 2.3'
 
   if $PROGRAM_NAME.end_with?('gem')
@@ -29,7 +29,12 @@ Gem::Specification.new do |spec|
   spec.require_paths = %w[lib]
 
   spec.metadata = {
+    'funding_uri' => 'https://karafka.io/#become-pro',
+    'homepage_uri' => 'https://karafka.io',
+    'changelog_uri' => 'https://github.com/karafka/waterdrop/blob/master/CHANGELOG.md',
+    'bug_tracker_uri' => 'https://github.com/karafka/waterdrop/issues',
     'source_code_uri' => 'https://github.com/karafka/waterdrop',
+    'documentation_uri' => 'https://github.com/karafka/waterdrop#readme',
     'rubygems_mfa_required' => 'true'
   }
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: waterdrop
 version: !ruby/object:Gem::Version
-  version: 2.4.10
+  version: 2.5.0
 platform: ruby
 authors:
 - Maciej Mensfeld
@@ -35,7 +35,7 @@ cert_chain:
   Qf04B9ceLUaC4fPVEz10FyobjaFoY4i32xRto3XnrzeAgfEe4swLq8bQsR3w/EF3
   MGU0FeSV2Yj7Xc2x/7BzLK8xQn5l7Yy75iPF+KP3vVmDHnNl
   -----END CERTIFICATE-----
-date: 2023-01-30 00:00:00.000000000 Z
+date: 2023-03-04 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: karafka-core
@@ -43,7 +43,7 @@ dependencies:
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 2.0.9
+        version: 2.0.12
     - - "<"
       - !ruby/object:Gem::Version
         version: 3.0.0
@@ -53,7 +53,7 @@ dependencies:
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 2.0.9
+        version: 2.0.12
     - - "<"
       - !ruby/object:Gem::Version
         version: 3.0.0
@@ -107,8 +107,9 @@ files:
 - lib/waterdrop/instrumentation/monitor.rb
 - lib/waterdrop/instrumentation/notifications.rb
 - lib/waterdrop/instrumentation/vendors/datadog/dashboard.json
-- lib/waterdrop/instrumentation/vendors/datadog/listener.rb
+- lib/waterdrop/instrumentation/vendors/datadog/metrics_listener.rb
 - lib/waterdrop/middleware.rb
+- lib/waterdrop/patches/rdkafka/client.rb
 - lib/waterdrop/patches/rdkafka/metadata.rb
 - lib/waterdrop/patches/rdkafka/producer.rb
 - lib/waterdrop/producer.rb
@@ -125,7 +126,12 @@ homepage: https://karafka.io
 licenses:
 - MIT
 metadata:
+  funding_uri: https://karafka.io/#become-pro
+  homepage_uri: https://karafka.io
+  changelog_uri: https://github.com/karafka/waterdrop/blob/master/CHANGELOG.md
+  bug_tracker_uri: https://github.com/karafka/waterdrop/issues
   source_code_uri: https://github.com/karafka/waterdrop
+  documentation_uri: https://github.com/karafka/waterdrop#readme
   rubygems_mfa_required: 'true'
 post_install_message: 
 rdoc_options: []
@@ -142,7 +148,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.4.1
+rubygems_version: 3.4.6
 signing_key: 
 specification_version: 4
 summary: Kafka messaging made easy!