waterdrop 2.0.1 → 2.0.5

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

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+module WaterDrop
+  module Instrumentation
+    module Callbacks
+      # Callback that kicks in when error occurs and is published in a background thread
+      class Error
+        # @param producer_id [String] id of the current producer
+        # @param client_name [String] rdkafka client name
+        # @param monitor [WaterDrop::Instrumentation::Monitor] monitor we are using
+        def initialize(producer_id, client_name, monitor)
+          @producer_id = producer_id
+          @client_name = client_name
+          @monitor = monitor
+        end
+
+        # Runs the instrumentation monitor with error
+        # @param client_name [String] rdkafka client name
+        # @param error [Rdkafka::Error] error that occurred
+        # @note If will only instrument on errors of the client of our producer
+        def call(client_name, error)
+          # Emit only errors related to our client
+          # Same as with statistics (mor explanation there)
+          return unless @client_name == client_name
+
+          @monitor.instrument(
+            'error.emitted',
+            producer_id: @producer_id,
+            error: error
+          )
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+module WaterDrop
+  module Instrumentation
+    # Namespace for handlers of callbacks emitted by the kafka client lib
+    module Callbacks
+      # Statistics callback handler
+      # @note We decorate the statistics with our own decorator because some of the metrics from
+      #   rdkafka are absolute. For example number of sent messages increases not in reference to
+      #   previous statistics emit but from the beginning of the process. We decorate it with diff
+      #   of all the numeric values against the data from the previous callback emit
+      class Statistics
+        # @param producer_id [String] id of the current producer
+        # @param client_name [String] rdkafka client name
+        # @param monitor [WaterDrop::Instrumentation::Monitor] monitor we are using
+        def initialize(producer_id, client_name, monitor)
+          @producer_id = producer_id
+          @client_name = client_name
+          @monitor = monitor
+          @statistics_decorator = StatisticsDecorator.new
+        end
+
+        # Emits decorated statistics to the monitor
+        # @param statistics [Hash] rdkafka statistics
+        def call(statistics)
+          # Emit only statistics related to our client
+          # rdkafka does not have per-instance statistics hook, thus we need to make sure that we
+          # emit only stats that are related to current producer. Otherwise we would emit all of
+          # all the time.
+          return unless @client_name == statistics['name']
+
+          @monitor.instrument(
+            'statistics.emitted',
+            producer_id: @producer_id,
+            statistics: @statistics_decorator.call(statistics)
+          )
+        end
+      end
+    end
+  end
+end

data/lib/water_drop/instrumentation/callbacks/statistics_decorator.rb

@@ -0,0 +1,77 @@
+# frozen_string_literal: true
+
+module WaterDrop
+  module Instrumentation
+    module Callbacks
+      # Many of the librdkafka statistics are absolute values instead of a gauge.
+      # This means, that for example number of messages sent is an absolute growing value
+      # instead of being a value of messages sent from the last statistics report.
+      # This decorator calculates the diff against previously emited stats, so we get also
+      # the diff together with the original values
+      class StatisticsDecorator
+        def initialize
+          @previous = {}.freeze
+        end
+
+        # @param emited_stats [Hash] original emited statistics
+        # @return [Hash] emited statistics extended with the diff data
+        # @note We modify the emited statistics, instead of creating new. Since we don't expose
+        #   any API to get raw data, users can just assume that the result of this decoration is
+        #   the proper raw stats that they can use
+        def call(emited_stats)
+          diff(
+            @previous,
+            emited_stats
+          )
+
+          @previous = emited_stats
+
+          emited_stats.freeze
+        end
+
+        private
+
+        # Calculates the diff of the provided values and modifies in place the emited statistics
+        #
+        # @param previous [Object] previous value from the given scope in which
+        #   we are
+        # @param current [Object] current scope from emitted statistics
+        # @return [Object] the diff if the values were numerics or the current scope
+        def diff(previous, current)
+          if current.is_a?(Hash)
+            # @note We cannot use #each_key as we modify the content of the current scope
+            #   in place (in case it's a hash)
+            current.keys.each do |key|
+              append(
+                current,
+                key,
+                diff((previous || {})[key], (current || {})[key])
+              )
+            end
+          end
+
+          # Diff can be computed only for numerics
+          return current unless current.is_a?(Numeric)
+          # If there was no previous value, delta is always zero
+          return 0 unless previous
+          # Should never happen but just in case, a type changed in between stats
+          return current unless previous.is_a?(Numeric)
+
+          current - previous
+        end
+
+        # Appends the result of the diff to a given key as long as the result is numeric
+        #
+        # @param current [Hash] current scope
+        # @param key [Symbol] key based on which we were diffing
+        # @param result [Object] diff result
+        def append(current, key, result)
+          return unless result.is_a?(Numeric)
+          return if current.frozen?
+
+          current["#{key}_d"] = result
+        end
+      end
+    end
+  end
+end

data/lib/water_drop/instrumentation/callbacks_manager.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+module WaterDrop
+  module Instrumentation
+    # This manager allows us to register multiple callbacks into a hook that is suppose to support
+    # a single callback
+    class CallbacksManager
+      # @return [::WaterDrop::Instrumentation::CallbacksManager]
+      def initialize
+        @callbacks = Concurrent::Hash.new
+      end
+
+      # Invokes all the callbacks registered one after another
+      #
+      # @param args [Object] any args that should go to the callbacks
+      def call(*args)
+        @callbacks.each_value { |a| a.call(*args) }
+      end
+
+      # Adds a callback to the manager
+      #
+      # @param id [String] id of the callback (used when deleting it)
+      # @param callable [#call] object that responds to a `#call` method
+      def add(id, callable)
+        @callbacks[id] = callable
+      end
+
+      # Removes the callback from the manager
+      # @param id [String] id of the callback we want to remove
+      def delete(id)
+        @callbacks.delete(id)
+      end
+    end
+  end
+end

data/lib/water_drop/instrumentation/monitor.rb

@@ -13,18 +13,24 @@ module WaterDrop
       # @note The non-error once support timestamp benchmarking
       EVENTS = %w[
         producer.closed
+
         message.produced_async
         message.produced_sync
+        message.acknowledged
+        message.buffered
+
         messages.produced_async
         messages.produced_sync
-        message.buffered
         messages.buffered
-        message.acknowledged
+
         buffer.flushed_async
         buffer.flushed_async.error
         buffer.flushed_sync
         buffer.flushed_sync.error
+
         statistics.emitted
+
+        error.emitted
       ].freeze
 
       private_constant :EVENTS

data/lib/water_drop/instrumentation.rb

@@ -2,6 +2,20 @@
 
 module WaterDrop
   # Namespace for all the things related with WaterDrop instrumentation process
+  # @note We do not
   module Instrumentation
+    class << self
+      # Builds a manager for statistics callbacks
+      # @return [WaterDrop::CallbacksManager]
+      def statistics_callbacks
+        @statistics_callbacks ||= CallbacksManager.new
+      end
+
+      # Builds a manager for error callbacks
+      # @return [WaterDrop::CallbacksManager]
+      def error_callbacks
+        @error_callbacks ||= CallbacksManager.new
+      end
+    end
   end
 end

data/lib/water_drop/patches/rdkafka/bindings.rb

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+module WaterDrop
+  module Patches
+    module Rdkafka
+      # Extends `Rdkafka::Bindings` with some extra methods and updates callbacks that we intend
+      # to work with in a bit different way than rdkafka itself
+      module Bindings
+        class << self
+          # Add extra methods that we need
+          # @param mod [::Rdkafka::Bindings] rdkafka bindings module
+          def included(mod)
+            mod.attach_function :rd_kafka_name, [:pointer], :string
+
+            # Default rdkafka setup for errors doest not propagate client details, thus it always
+            # publishes all the stuff for all rdkafka instances. We change that by providing
+            # function that fetches the instance name, allowing us to have better notifications
+            mod.send(:remove_const, :ErrorCallback)
+            mod.const_set(:ErrorCallback, build_error_callback)
+          end
+
+          # @return [FFI::Function] overwritten callback function
+          def build_error_callback
+            FFI::Function.new(
+              :void, %i[pointer int string pointer]
+            ) do |client_prr, err_code, reason, _opaque|
+              return nil unless ::Rdkafka::Config.error_callback
+
+              name = ::Rdkafka::Bindings.rd_kafka_name(client_prr)
+
+              error = ::Rdkafka::RdkafkaError.new(err_code, broker_message: reason)
+
+              ::Rdkafka::Config.error_callback.call(name, error)
+            end
+          end
+        end
+      end
+    end
+  end
+end
+
+::Rdkafka::Bindings.include(::WaterDrop::Patches::Rdkafka::Bindings)

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

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+module WaterDrop
+  # Patches to external components
+  module Patches
+    # Rdkafka related patches
+    module Rdkafka
+      # Rdkafka::Producer patches
+      module Producer
+        # Adds a method that allows us to get the native kafka producer name
+        # @return [String] producer instance name
+        def name
+          ::Rdkafka::Bindings.rd_kafka_name(@native_kafka)
+        end
+      end
+    end
+  end
+end
+
+::Rdkafka::Producer.include ::WaterDrop::Patches::Rdkafka::Producer

data/lib/water_drop/producer/builder.rb

@@ -12,51 +12,16 @@ module WaterDrop
       def call(producer, config)
         return DummyClient.new unless config.deliver
 
-        Rdkafka::Config.logger = config.logger
-        Rdkafka::Config.statistics_callback = build_statistics_callback(producer, config.monitor)
-
         client = Rdkafka::Config.new(config.kafka.to_h).producer
-        client.delivery_callback = build_delivery_callback(producer, config.monitor)
-        client
-      end
 
-      private
+        # 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,
+          config.monitor
+        )
 
-      # Creates a proc that we want to run upon each successful message delivery
-      #
-      # @param producer [Producer]
-      # @param monitor [Object] monitor we want to use
-      # @return [Proc] delivery callback
-      def build_delivery_callback(producer, monitor)
-        lambda do |delivery_report|
-          monitor.instrument(
-            'message.acknowledged',
-            producer: producer,
-            offset: delivery_report.offset,
-            partition: delivery_report.partition
-          )
-        end
-      end
-
-      # Creates a proc that we want to run upon each statistics callback execution
-      #
-      # @param producer [Producer]
-      # @param monitor [Object] monitor we want to use
-      # @return [Proc] statistics callback
-      # @note We decorate the statistics with our own decorator because some of the metrics from
-      #   rdkafka are absolute. For example number of sent messages increases not in reference to
-      #   previous statistics emit but from the beginning of the process. We decorate it with diff
-      #   of all the numeric values against the data from the previous callback emit
-      def build_statistics_callback(producer, monitor)
-        statistics_decorator = StatisticsDecorator.new
-
-        lambda do |statistics|
-          monitor.instrument(
-            'statistics.emitted',
-            producer: producer,
-            statistics: statistics_decorator.call(statistics)
-          )
-        end
+        client
       end
     end
   end

data/lib/water_drop/producer.rb

@@ -80,6 +80,19 @@ module WaterDrop
 
         @pid = Process.pid
         @client = Builder.new.call(self, @config)
+
+        # Register statistics runner for this particular type of callbacks
+        ::WaterDrop::Instrumentation.statistics_callbacks.add(
+          @id,
+          Instrumentation::Callbacks::Statistics.new(@id, @client.name, @config.monitor)
+        )
+
+        # Register error tracking callback
+        ::WaterDrop::Instrumentation.error_callbacks.add(
+          @id,
+          Instrumentation::Callbacks::Error.new(@id, @client.name, @config.monitor)
+        )
+
         @status.connected!
       end
 
@@ -101,13 +114,19 @@ module WaterDrop
           # This should be used only in case a producer was not closed properly and forgotten
           ObjectSpace.undefine_finalizer(id)
 
-          # Flush has it's own buffer mutex but even if it is blocked, flushing can still happen
+          # 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(false)
+          flush(true)
 
           # We should not close the client in several threads the same time
           # It is safe to run it several times but not exactly the same moment
-          client.close
+          # 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
+
+          # Remove callbacks runners that were registered
+          ::WaterDrop::Instrumentation.statistics_callbacks.delete(@id)
+          ::WaterDrop::Instrumentation.error_callbacks.delete(@id)
 
           @status.closed!
         end

data/lib/water_drop/version.rb

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

data/lib/water_drop.rb

@@ -28,3 +28,9 @@ Zeitwerk::Loader
   .tap { |loader| loader.ignore("#{__dir__}/waterdrop.rb") }
   .tap(&:setup)
   .tap(&:eager_load)
+
+# Rdkafka uses a single global callback for things. We bypass that by injecting a manager for
+# each callback type. Callback manager allows us to register more than one callback
+# @note Those managers are also used by Karafka for consumer related statistics
+Rdkafka::Config.statistics_callback = WaterDrop::Instrumentation.statistics_callbacks
+Rdkafka::Config.error_callback = WaterDrop::Instrumentation.error_callbacks

data/waterdrop.gemspec

@@ -14,14 +14,14 @@ Gem::Specification.new do |spec|
   spec.homepage      = 'https://github.com/karafka/waterdrop'
   spec.summary       = 'Kafka messaging made easy!'
   spec.description   = spec.summary
-  spec.license       = 'LGPL-3.0'
+  spec.license       = 'MIT'
 
   spec.add_dependency 'concurrent-ruby', '>= 1.1'
-  spec.add_dependency 'dry-configurable', '~> 0.8'
-  spec.add_dependency 'dry-monitor', '~> 0.3'
-  spec.add_dependency 'dry-validation', '~> 1.3'
-  spec.add_dependency 'rdkafka', '>= 0.6.0'
-  spec.add_dependency 'zeitwerk', '~> 2.1'
+  spec.add_dependency 'dry-configurable', '~> 0.13'
+  spec.add_dependency 'dry-monitor', '~> 0.5'
+  spec.add_dependency 'dry-validation', '~> 1.7'
+  spec.add_dependency 'rdkafka', '>= 0.10'
+  spec.add_dependency 'zeitwerk', '~> 2.3'
 
   spec.required_ruby_version = '>= 2.6.0'
 

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: waterdrop
 version: !ruby/object:Gem::Version
-  version: 2.0.1
+  version: 2.0.5
 platform: ruby
 authors:
 - Maciej Mensfeld
@@ -11,30 +11,30 @@ cert_chain:
 - |
   -----BEGIN CERTIFICATE-----
   MIIEODCCAqCgAwIBAgIBATANBgkqhkiG9w0BAQsFADAjMSEwHwYDVQQDDBhtYWNp
-  ZWovREM9bWVuc2ZlbGQvREM9cGwwHhcNMjAwODExMDkxNTM3WhcNMjEwODExMDkx
-  NTM3WjAjMSEwHwYDVQQDDBhtYWNpZWovREM9bWVuc2ZlbGQvREM9cGwwggGiMA0G
-  CSqGSIb3DQEBAQUAA4IBjwAwggGKAoIBgQDCpXsCgmINb6lHBXXBdyrgsBPSxC4/
-  2H+weJ6L9CruTiv2+2/ZkQGtnLcDgrD14rdLIHK7t0o3EKYlDT5GhD/XUVhI15JE
-  N7IqnPUgexe1fbZArwQ51afxz2AmPQN2BkB2oeQHXxnSWUGMhvcEZpfbxCCJH26w
-  hS0Ccsma8yxA6hSlGVhFVDuCr7c2L1di6cK2CtIDpfDaWqnVNJEwBYHIxrCoWK5g
-  sIGekVt/admS9gRhIMaIBg+Mshth5/DEyWO2QjteTodItlxfTctrfmiAl8X8T5JP
-  VXeLp5SSOJ5JXE80nShMJp3RFnGw5fqjX/ffjtISYh78/By4xF3a25HdWH9+qO2Z
-  tx0wSGc9/4gqNM0APQnjN/4YXrGZ4IeSjtE+OrrX07l0TiyikzSLFOkZCAp8oBJi
-  Fhlosz8xQDJf7mhNxOaZziqASzp/hJTU/tuDKl5+ql2icnMv5iV/i6SlmvU29QNg
-  LCV71pUv0pWzN+OZbHZKWepGhEQ3cG9MwvkCAwEAAaN3MHUwCQYDVR0TBAIwADAL
-  BgNVHQ8EBAMCBLAwHQYDVR0OBBYEFImGed2AXS070ohfRidiCEhXEUN+MB0GA1Ud
+  ZWovREM9bWVuc2ZlbGQvREM9cGwwHhcNMjEwODExMTQxNTEzWhcNMjIwODExMTQx
+  NTEzWjAjMSEwHwYDVQQDDBhtYWNpZWovREM9bWVuc2ZlbGQvREM9cGwwggGiMA0G
+  CSqGSIb3DQEBAQUAA4IBjwAwggGKAoIBgQDV2jKH4Ti87GM6nyT6D+ESzTI0MZDj
+  ak2/TEwnxvijMJyCCPKT/qIkbW4/f0VHM4rhPr1nW73sb5SZBVFCLlJcOSKOBdUY
+  TMY+SIXN2EtUaZuhAOe8LxtxjHTgRHvHcqUQMBENXTISNzCo32LnUxweu66ia4Pd
+  1mNRhzOqNv9YiBZvtBf7IMQ+sYdOCjboq2dlsWmJiwiDpY9lQBTnWORnT3mQxU5x
+  vPSwnLB854cHdCS8fQo4DjeJBRZHhEbcE5sqhEMB3RZA3EtFVEXOxlNxVTS3tncI
+  qyNXiWDaxcipaens4ObSY1C2HTV7OWb7OMqSCIybeYTSfkaSdqmcl4S6zxXkjH1J
+  tnjayAVzD+QVXGijsPLE2PFnJAh9iDET2cMsjabO1f6l1OQNyAtqpcyQcgfnyW0z
+  g7tGxTYD+6wJHffM9d9txOUw6djkF6bDxyqB8lo4Z3IObCx18AZjI9XPS9QG7w6q
+  LCWuMG2lkCcRgASqaVk9fEf9yMc2xxz5o3kCAwEAAaN3MHUwCQYDVR0TBAIwADAL
+  BgNVHQ8EBAMCBLAwHQYDVR0OBBYEFBqUFCKCOe5IuueUVqOB991jyCLLMB0GA1Ud
   EQQWMBSBEm1hY2llakBtZW5zZmVsZC5wbDAdBgNVHRIEFjAUgRJtYWNpZWpAbWVu
-  c2ZlbGQucGwwDQYJKoZIhvcNAQELBQADggGBAKiHpwoENVrMi94V1zD4o8/6G3AU
-  gWz4udkPYHTZLUy3dLznc/sNjdkJFWT3E6NKYq7c60EpJ0m0vAEg5+F5pmNOsvD3
-  2pXLj9kisEeYhR516HwXAvtngboUcb75skqvBCU++4Pu7BRAPjO1/ihLSBexbwSS
-  fF+J5OWNuyHHCQp+kGPLtXJe2yUYyvSWDj3I2//Vk0VhNOIlaCS1+5/P3ZJThOtm
-  zJUBI7h3HgovwRpcnmk2mXTmU4Zx/bCzX8EA6VY0khEvnmiq7S6eBF0H9qH8KyQ6
-  EkVLpvmUDFcf/uNaBQdazEMB5jYtwoA8gQlANETNGPi51KlkukhKgaIEDMkBDJOx
-  65N7DzmkcyY0/GwjIVIxmRhcrCt1YeCUElmfFx0iida1/YRm6sB2AXqScc1+ECRi
-  2DND//YJUikn1zwbz1kT70XmHd97B4Eytpln7K+M1u2g1pHVEPW4owD/ammXNpUy
-  nt70FcDD4yxJQ+0YNiHd0N8IcVBM1TMIVctMNQ==
+  c2ZlbGQucGwwDQYJKoZIhvcNAQELBQADggGBADD0/UuTTFgW+CGk2U0RDw2RBOca
+  W2LTF/G7AOzuzD0Tc4voc7WXyrgKwJREv8rgBimLnNlgmFJLmtUCh2U/MgxvcilH
+  yshYcbseNvjkrtYnLRlWZR4SSB6Zei5AlyGVQLPkvdsBpNegcG6w075YEwzX/38a
+  8V9B/Yri2OGELBz8ykl7BsXUgNoUPA/4pHF6YRLz+VirOaUIQ4JfY7xGj6fSOWWz
+  /rQ/d77r6o1mfJYM/3BRVg73a3b7DmRnE5qjwmSaSQ7u802pJnLesmArch0xGCT/
+  fMmRli1Qb+6qOTl9mzD6UDMAyFR4t6MStLm0mIEqM0nBO5nUdUWbC7l9qXEf8XBE
+  2DP28p3EqSuS+lKbAWKcqv7t0iRhhmaod+Yn9mcrLN1sa3q3KSQ9BCyxezCD4Mk2
+  R2P11bWoCtr70BsccVrN8jEhzwXngMyI2gVt750Y+dbTu1KgRqZKp/ECe7ZzPzXj
+  pIy9vHxTANKYVyI4qj8OrFdEM5BQNu8oQpL0iQ==
   -----END CERTIFICATE-----
-date: 2021-06-06 00:00:00.000000000 Z
+date: 2021-11-28 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: concurrent-ruby
@@ -56,70 +56,70 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '0.8'
+        version: '0.13'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '0.8'
+        version: '0.13'
 - !ruby/object:Gem::Dependency
   name: dry-monitor
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '0.3'
+        version: '0.5'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '0.3'
+        version: '0.5'
 - !ruby/object:Gem::Dependency
   name: dry-validation
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '1.3'
+        version: '1.7'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '1.3'
+        version: '1.7'
 - !ruby/object:Gem::Dependency
   name: rdkafka
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 0.6.0
+        version: '0.10'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 0.6.0
+        version: '0.10'
 - !ruby/object:Gem::Dependency
   name: zeitwerk
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '2.1'
+        version: '2.3'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '2.1'
+        version: '2.3'
 description: Kafka messaging made easy!
 email:
 - maciej@mensfeld.pl
@@ -129,7 +129,6 @@ extra_rdoc_files: []
 files:
 - ".coditsu/ci.yml"
 - ".diffend.yml"
-- ".github/FUNDING.yml"
 - ".github/workflows/ci.yml"
 - ".gitignore"
 - ".rspec"
@@ -138,7 +137,7 @@ files:
 - CHANGELOG.md
 - Gemfile
 - Gemfile.lock
-- LICENSE
+- MIT-LICENSE
 - README.md
 - certs/mensfeld.pem
 - config/errors.yml
@@ -150,14 +149,20 @@ files:
 - lib/water_drop/contracts/message.rb
 - lib/water_drop/errors.rb
 - lib/water_drop/instrumentation.rb
+- lib/water_drop/instrumentation/callbacks/delivery.rb
+- lib/water_drop/instrumentation/callbacks/error.rb
+- lib/water_drop/instrumentation/callbacks/statistics.rb
+- lib/water_drop/instrumentation/callbacks/statistics_decorator.rb
+- lib/water_drop/instrumentation/callbacks_manager.rb
 - lib/water_drop/instrumentation/monitor.rb
 - lib/water_drop/instrumentation/stdout_listener.rb
+- lib/water_drop/patches/rdkafka/bindings.rb
+- lib/water_drop/patches/rdkafka/producer.rb
 - lib/water_drop/producer.rb
 - lib/water_drop/producer/async.rb
 - lib/water_drop/producer/buffer.rb
 - lib/water_drop/producer/builder.rb
 - lib/water_drop/producer/dummy_client.rb
-- lib/water_drop/producer/statistics_decorator.rb
 - lib/water_drop/producer/status.rb
 - lib/water_drop/producer/sync.rb
 - lib/water_drop/version.rb
@@ -166,7 +171,7 @@ files:
 - waterdrop.gemspec
 homepage: https://github.com/karafka/waterdrop
 licenses:
-- LGPL-3.0
+- MIT
 metadata: {}
 post_install_message: 
 rdoc_options: []
@@ -183,7 +188,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.2.15
+rubygems_version: 3.2.25
 signing_key: 
 specification_version: 4
 summary: Kafka messaging made easy!

data/.github/FUNDING.yml

@@ -1 +0,0 @@
-open_collective: karafka