waterdrop 2.3.1 → 2.4.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: b73f2d492f65c1f7d410579f7bba30298eb4e3c2d7379b789e2cb10bda820eae
-  data.tar.gz: 3ba7625727180dbeda0e0c29a6b36d83bae5d8b24103dd59995a7d96ca804062
+  metadata.gz: 0bd7288d6c0c7a6f356f050af309899cad41e6fcf202c945229231d7058194e1
+  data.tar.gz: 727738b727dccf8e2d7b4eb7c3f25b1c7ed761eb958eae4ba818c7402839a6c7
 SHA512:
-  metadata.gz: b073fdee0c430f1036d4c3219ba236f02ec33fe5350130d4fd448338f34f8ae3c63b424b093c78665c2f78ec9bfbc1b213a70dc536bd29110dae8530c208ceed
-  data.tar.gz: 01ca4ea0a71137bbe3051e896319b9cdb81d6d6144945c0c85c95ce4644e66b3cbac5ad2187a1eb3073bc0a76783534872e713644b1fe90139a8b3bf6f01055f
+  metadata.gz: 95f69c8cd00d33e04747f1447ca9fe40de88941869925662116427b14da7f0eb0a04c7eada0e00ea6c226dd8be90484b7e97e6d34f9c7f0a11333bfede37e03c
+  data.tar.gz: fa43e25469180c9d9e65f31b4d79554b35c090e79d8812586d614a77acafe04bb873f24ed58f739c4523696282bef8dfa05e0fa0358ca808bfd2df038bf3d55b

data/CHANGELOG.md

@@ -1,5 +1,17 @@
 # WaterDrop changelog
 
+## 2.4.0 (2022-07-28)
+- Small refactor of the DataDog/Statsd listener to align for future extraction to `karafka-common`.
+- Replace `dry-monitor` with home-brew notification layer (API compatible) and allow for usage with `ActiveSupport::Notifications`.
+- Remove all the common code into `karafka-core` and add it as a dependency.
+
+## 2.3.3 (2022-07-18)
+- Replace `dry-validation` with home-brew validation layer and drop direct dependency on `dry-validation`.
+- Remove indirect dependency on dry-configurable from DataDog listener (no changes required).
+
+## 2.3.2 (2022-07-17)
+- Replace `dry-configurable` with home-brew config and drop direct dependency on `dry-configurable`.
+
 ## 2.3.1 (2022-06-17)
 - Update rdkafka patches to align with `0.12.0` and `0.11.1` support.
 

data/Gemfile.lock

@@ -1,18 +1,15 @@
 PATH
   remote: .
   specs:
-    waterdrop (2.3.1)
-      concurrent-ruby (>= 1.1)
-      dry-configurable (~> 0.13)
-      dry-monitor (~> 0.5)
-      dry-validation (~> 1.7)
+    waterdrop (2.4.0)
+      karafka-core (~> 2.0)
       rdkafka (>= 0.10)
       zeitwerk (~> 2.3)
 
 GEM
   remote: https://rubygems.org/
   specs:
-    activesupport (7.0.3)
+    activesupport (7.0.3.1)
       concurrent-ruby (~> 1.0, >= 1.0.2)
       i18n (>= 1.6, < 2)
       minitest (>= 5.1)
@@ -21,52 +18,15 @@ GEM
     concurrent-ruby (1.1.10)
     diff-lcs (1.5.0)
     docile (1.4.0)
-    dry-configurable (0.15.0)
-      concurrent-ruby (~> 1.0)
-      dry-core (~> 0.6)
-    dry-container (0.9.0)
-      concurrent-ruby (~> 1.0)
-      dry-configurable (~> 0.13, >= 0.13.0)
-    dry-core (0.7.1)
-      concurrent-ruby (~> 1.0)
-    dry-events (0.3.0)
-      concurrent-ruby (~> 1.0)
-      dry-core (~> 0.5, >= 0.5)
-    dry-inflector (0.2.1)
-    dry-initializer (3.1.1)
-    dry-logic (1.2.0)
-      concurrent-ruby (~> 1.0)
-      dry-core (~> 0.5, >= 0.5)
-    dry-monitor (0.5.0)
-      dry-configurable (~> 0.13, >= 0.13.0)
-      dry-core (~> 0.5, >= 0.5)
-      dry-events (~> 0.2)
-    dry-schema (1.9.2)
-      concurrent-ruby (~> 1.0)
-      dry-configurable (~> 0.13, >= 0.13.0)
-      dry-core (~> 0.5, >= 0.5)
-      dry-initializer (~> 3.0)
-      dry-logic (~> 1.0)
-      dry-types (~> 1.5)
-    dry-types (1.5.1)
-      concurrent-ruby (~> 1.0)
-      dry-container (~> 0.3)
-      dry-core (~> 0.5, >= 0.5)
-      dry-inflector (~> 0.1, >= 0.1.2)
-      dry-logic (~> 1.0, >= 1.0.2)
-    dry-validation (1.8.1)
-      concurrent-ruby (~> 1.0)
-      dry-container (~> 0.7, >= 0.7.1)
-      dry-core (~> 0.5, >= 0.5)
-      dry-initializer (~> 3.0)
-      dry-schema (~> 1.8, >= 1.8.0)
     factory_bot (6.2.1)
       activesupport (>= 5.0.0)
     ffi (1.15.5)
-    i18n (1.10.0)
+    i18n (1.12.0)
       concurrent-ruby (~> 1.0)
+    karafka-core (2.0.0)
+      concurrent-ruby (>= 1.1)
     mini_portile2 (2.8.0)
-    minitest (5.16.0)
+    minitest (5.16.2)
     rake (13.0.6)
     rdkafka (0.12.0)
       ffi (~> 1.15)
@@ -91,12 +51,11 @@ GEM
       simplecov_json_formatter (~> 0.1)
     simplecov-html (0.12.3)
     simplecov_json_formatter (0.1.4)
-    tzinfo (2.0.4)
+    tzinfo (2.0.5)
       concurrent-ruby (~> 1.0)
     zeitwerk (2.6.0)
 
 PLATFORMS
-  arm64-darwin-21
   x86_64-linux
 
 DEPENDENCIES

data/README.md

@@ -1,8 +1,8 @@
 # WaterDrop
 
-**Note**: Documentation presented here refers to WaterDrop `2.0.0`.
+**Note**: Documentation presented here refers to WaterDrop `2.x`.
 
-WaterDrop `2.0` does **not** work with Karafka `1.*` and aims to either work as a standalone producer outside of Karafka `1.*` ecosystem or as a part of soon to be released Karafka `2.0.*`.
+WaterDrop `2.x` works with Karafka `2.*` and aims to either work as a standalone producer or as a part of the Karafka `2.*`.
 
 Please refer to [this](https://github.com/karafka/waterdrop/tree/1.4) branch and its documentation for details about WaterDrop `1.*` usage.
 
@@ -10,17 +10,17 @@ Please refer to [this](https://github.com/karafka/waterdrop/tree/1.4) branch and
 [![Gem Version](https://badge.fury.io/rb/waterdrop.svg)](http://badge.fury.io/rb/waterdrop)
 [![Join the chat at https://slack.karafka.io](https://raw.githubusercontent.com/karafka/misc/master/slack.svg)](https://slack.karafka.io)
 
-Gem used to send messages to Kafka in an easy way with an extra validation layer. It is a part of the [Karafka](https://github.com/karafka/karafka) ecosystem.
+A gem to send messages to Kafka easily with an extra validation layer. It is a part of the [Karafka](https://github.com/karafka/karafka) ecosystem.
 
 It:
 
- - Is thread safe
+ - Is thread-safe
  - Supports sync producing
  - Supports async producing
  - Supports buffering
  - Supports producing messages to multiple clusters
  - Supports multiple delivery policies
- - Works with Kafka 1.0+ and Ruby 2.6+
+ - Works with Kafka `1.0+` and Ruby `2.7+`
 
 ## Table of contents
 
@@ -30,6 +30,8 @@ It:
   * [Kafka configuration options](#kafka-configuration-options)
 - [Usage](#usage)
   * [Basic usage](#basic-usage)
+  * [Using WaterDrop across the application and with Ruby on Rails](#using-waterdrop-across-the-application-and-with-ruby-on-rails)
+  * [Using WaterDrop with a connection-pool](#using-waterdrop-with-a-connection-pool)
   * [Buffering](#buffering)
       + [Using WaterDrop to buffer messages based on the application logic](#using-waterdrop-to-buffer-messages-based-on-the-application-logic)
       + [Using WaterDrop with rdkafka buffers to achieve periodic auto-flushing](#using-waterdrop-with-rdkafka-buffers-to-achieve-periodic-auto-flushing)
@@ -42,6 +44,8 @@ It:
 
 ## Installation
 
+**Note**: If you want to both produce and consume messages, please use [Karafka](https://github.com/karafka/karafka/). It integrates WaterDrop automatically.
+
 Add this to your Gemfile:
 
 ```ruby
@@ -56,7 +60,7 @@ bundle install
 
 ## Setup
 
-WaterDrop is a complex tool, that contains multiple configuration options. To keep everything organized, all the configuration options were divided into two groups:
+WaterDrop is a complex tool that contains multiple configuration options. To keep everything organized, all the configuration options were divided into two groups:
 
 - WaterDrop options - options directly related to WaterDrop and its components
 - Kafka driver options - options related to `rdkafka`
@@ -103,8 +107,6 @@ You can create producers with different `kafka` settings. Documentation of the a
 
 ## Usage
 
-Please refer to the [documentation](https://www.rubydoc.info/gems/waterdrop) in case you're interested in the more advanced API.
-
 ### Basic usage
 
 To send Kafka messages, just create a producer and use it:
@@ -157,6 +159,41 @@ Here are all the things you can provide in the message hash:
 
 Keep in mind, that message you want to send should be either binary or stringified (to_s, to_json, etc).
 
+### Using WaterDrop across the application and with Ruby on Rails
+
+If you plan to both produce and consume messages using Kafka, you should install and use [Karafka](https://github.com/karafka/karafka). It integrates automatically with Ruby on Rails applications and auto-configures WaterDrop producer to make it accessible via `Karafka#producer` method.
+
+If you want to only produce messages from within your application, since WaterDrop is thread-safe you can create a single instance in an initializer like so:
+
+```ruby
+KAFKA_PRODUCER = WaterDrop::Producer.new
+
+KAFKA_PRODUCER.setup do |config|
+  config.kafka = { 'bootstrap.servers': 'localhost:9092' }
+end
+
+# And just dispatch messages
+KAFKA_PRODUCER.produce_sync(topic: 'my-topic', payload: 'my message')
+```
+
+### Using WaterDrop with a connection-pool
+
+While WaterDrop is thread-safe, there is no problem in using it with a connection pool inside high-intensity applications. The only thing worth keeping in mind, is that WaterDrop instances should be shutdown before the application is closed.
+
+```ruby
+KAFKA_PRODUCERS_CP = ConnectionPool.new do
+  WaterDrop::Producer.new do |config|
+    config.kafka = { 'bootstrap.servers': 'localhost:9092' }
+  end
+end
+
+KAFKA_PRODUCERS_CP.with do |producer|
+  producer.produce_async(topic: 'my-topic', payload: 'my message')
+end
+
+KAFKA_PRODUCERS_CP.shutdown { |producer| producer.close }
+```
+
 ### Buffering
 
 WaterDrop producers support buffering messages in their internal buffers and on the `rdkafka` level via `queue.buffering.*` set of settings.
@@ -316,6 +353,8 @@ producer.monitor.subscribe(listener)
 
 You can also find [here](https://github.com/karafka/waterdrop/blob/master/lib/waterdrop/instrumentation/vendors/datadog/dashboard.json) a ready to import DataDog dashboard configuration file that you can use to monitor all of your producers.
 
+![Example WaterDrop DD dashboard](https://raw.githubusercontent.com/karafka/misc/master/printscreens/waterdrop_dd_dashboard_example.png)
+
 ### Error notifications
 
 WaterDrop allows you to listen to all errors that occur while producing messages and in its internal background threads. Things like reconnecting to Kafka upon network errors and others unrelated to publishing messages are all available under `error.occurred` notification key. You can subscribe to this event to ensure your setup is healthy and without any problems that would otherwise go unnoticed as long as messages are delivered.

data/config/errors.yml

@@ -1,7 +1,30 @@
 en:
-  dry_validation:
-    errors:
-      invalid_key_type: all keys need to be of type String
-      invalid_value_type: all values need to be of type String
-      max_payload_size: is more than `max_payload_size` config value
+  validations:
+    config:
+      missing: must be present
+      logger_format: must be present
+      deliver_format: must be boolean
+      id_format: must be a non-empty string
+      max_payload_size_format: must be an integer that is equal or bigger than 1
+      wait_timeout_format: must be a numeric that is bigger than 0
+      max_wait_timeout_format: must be an integer that is equal or bigger than 0
+      kafka_format: must be a hash with symbol based keys
       kafka_key_must_be_a_symbol: All keys under the kafka settings scope need to be symbols
+
+    message:
+      missing: must be present
+      partition_format: must be an integer greater or equal to -1
+      topic_format: 'does not match the topic allowed format'
+      partition_key_format: must be a non-empty string
+      timestamp_format: must be either time or integer
+      payload_format: must be string
+      headers_format: must be a hash
+      key_format: must be a non-empty string
+      payload_max_size: is more than `max_payload_size` config value
+      headers_invalid_key_type: all headers keys need to be of type String
+      headers_invalid_value_type: all headers values need to be of type String
+
+    test:
+      missing: must be present
+      nested.id_format: 'is invalid'
+      nested.id2_format: 'is invalid'

data/lib/waterdrop/config.rb

@@ -5,7 +5,7 @@
 module WaterDrop
   # Configuration object for setting up all options required by WaterDrop
   class Config
-    include Dry::Configurable
+    include ::Karafka::Core::Configurable
 
     # Defaults for kafka settings, that will be overwritten only if not present already
     KAFKA_DEFAULTS = {
@@ -68,6 +68,8 @@ module WaterDrop
 
         ::Rdkafka::Config.logger = config.logger
       end
+
+      self
     end
 
     private
@@ -75,7 +77,7 @@ module WaterDrop
     # Propagates the kafka setting defaults unless they are already present
     # This makes it easier to set some values that users usually don't change but still allows them
     # to overwrite the whole hash if they want to
-    # @param config [Dry::Configurable::Config] dry config of this producer
+    # @param config [WaterDrop::Configurable::Node] config of this producer
     def merge_kafka_defaults!(config)
       KAFKA_DEFAULTS.each do |key, value|
         next if config.kafka.key?(key)

data/lib/waterdrop/contracts/config.rb

@@ -3,27 +3,37 @@
 module WaterDrop
   module Contracts
     # Contract with validation rules for WaterDrop configuration details
-    class Config < Base
-      params do
-        required(:id).filled(:str?)
-        required(:logger).filled
-        required(:deliver).filled(:bool?)
-        required(:max_payload_size).filled(:int?, gteq?: 1)
-        required(:max_wait_timeout).filled(:number?, gteq?: 0)
-        required(:wait_timeout).filled(:number?, gt?: 0)
-        required(:kafka).filled(:hash?)
+    class Config < ::Karafka::Core::Contractable::Contract
+      configure do |config|
+        config.error_messages = YAML.safe_load(
+          File.read(
+            File.join(WaterDrop.gem_root, 'config', 'errors.yml')
+          )
+        ).fetch('en').fetch('validations').fetch('config')
       end
 
+      required(:id) { |val| val.is_a?(String) && !val.empty? }
+      required(:logger) { |val| !val.nil? }
+      required(:deliver) { |val| [true, false].include?(val) }
+      required(:max_payload_size) { |val| val.is_a?(Integer) && val >= 1 }
+      required(:max_wait_timeout) { |val| val.is_a?(Numeric) && val >= 0 }
+      required(:wait_timeout) { |val| val.is_a?(Numeric) && val.positive? }
+      required(:kafka) { |val| val.is_a?(Hash) && !val.empty? }
+
       # rdkafka allows both symbols and strings as keys for config but then casts them to strings
       # This can be confusing, so we expect all keys to be symbolized
-      rule(:kafka) do
-        next unless value.is_a?(Hash)
+      virtual do |config, errors|
+        next true unless errors.empty?
+
+        errors = []
 
-        value.each_key do |key|
-          next if key.is_a?(Symbol)
+        config
+          .fetch(:kafka)
+          .keys
+          .reject { |key| key.is_a?(Symbol) }
+          .each { |key| errors << [[:kafka, key], :kafka_key_must_be_a_symbol] }
 
-          key(:"kafka.#{key}").failure(:kafka_key_must_be_a_symbol)
-        end
+        errors
       end
     end
   end

data/lib/waterdrop/contracts/message.rb

@@ -4,36 +4,56 @@ module WaterDrop
   module Contracts
     # Contract with validation rules for validating that all the message options that
     # we provide to producer ale valid and usable
-    class Message < Base
+    class Message < ::Karafka::Core::Contractable::Contract
+      configure do |config|
+        config.error_messages = YAML.safe_load(
+          File.read(
+            File.join(WaterDrop.gem_root, 'config', 'errors.yml')
+          )
+        ).fetch('en').fetch('validations').fetch('message')
+      end
+
       # Regex to check that topic has a valid format
       TOPIC_REGEXP = /\A(\w|-|\.)+\z/
 
-      # Checks, that the given value is a string
-      STRING_ASSERTION = ->(value) { value.is_a?(String) }.to_proc
+      private_constant :TOPIC_REGEXP
 
-      private_constant :TOPIC_REGEXP, :STRING_ASSERTION
+      attr_reader :max_payload_size
 
-      option :max_payload_size
-
-      params do
-        required(:topic).filled(:str?, format?: TOPIC_REGEXP)
-        required(:payload).filled(:str?)
-        optional(:key).maybe(:str?, :filled?)
-        optional(:partition).filled(:int?, gteq?: -1)
-        optional(:partition_key).maybe(:str?, :filled?)
-        optional(:timestamp).maybe { time? | int? }
-        optional(:headers).maybe(:hash?)
+      # @param max_payload_size [Integer] max payload size
+      def initialize(max_payload_size:)
+        super()
+        @max_payload_size = max_payload_size
       end
 
-      rule(:headers) do
-        next unless value.is_a?(Hash)
+      required(:topic) { |val| val.is_a?(String) && TOPIC_REGEXP.match?(val) }
+      required(:payload) { |val| val.is_a?(String) }
+      optional(:key) { |val| val.nil? || (val.is_a?(String) && !val.empty?) }
+      optional(:partition) { |val| val.is_a?(Integer) && val >= -1 }
+      optional(:partition_key) { |val| val.nil? || (val.is_a?(String) && !val.empty?) }
+      optional(:timestamp) { |val| val.nil? || (val.is_a?(Time) || val.is_a?(Integer)) }
+      optional(:headers) { |val| val.nil? || val.is_a?(Hash) }
+
+      virtual do |config, errors|
+        next true unless errors.empty?
+        next true unless config.key?(:headers)
+        next true if config[:headers].nil?
 
-        key.failure(:invalid_key_type) unless value.keys.all?(&STRING_ASSERTION)
-        key.failure(:invalid_value_type) unless value.values.all?(&STRING_ASSERTION)
+        errors = []
+
+        config.fetch(:headers).each do |key, value|
+          errors << [%i[headers], :invalid_key_type] unless key.is_a?(String)
+          errors << [%i[headers], :invalid_value_type] unless value.is_a?(String)
+        end
+
+        errors
       end
 
-      rule(:payload) do
-        key.failure(:max_payload_size) if value.bytesize > max_payload_size
+      virtual do |config, errors, validator|
+        next true unless errors.empty?
+        next true if config[:payload].bytesize <= validator.max_payload_size
+
+        [[%i[payload], :max_size]]
       end
     end
   end

data/lib/waterdrop/instrumentation/monitor.rb

@@ -2,41 +2,18 @@
 
 module WaterDrop
   module Instrumentation
-    # Monitor is used to hookup external monitoring services to monitor how WaterDrop works
-    # Since it is a pub-sub based on dry-monitor, you can use as many subscribers/loggers at the
-    # same time, which means that you might have for example file logging and NewRelic at the same
-    # time
-    # @note This class acts as a singleton because we are only permitted to have single monitor
-    #   per running process (just as logger)
-    class Monitor < Dry::Monitor::Notifications
-      # List of events that we support in the system and to which a monitor client can hook up
-      # @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
-        messages.buffered
-
-        buffer.flushed_async
-        buffer.flushed_sync
-
-        statistics.emitted
-
-        error.occurred
-      ].freeze
-
-      private_constant :EVENTS
-
-      # @return [WaterDrop::Instrumentation::Monitor] monitor instance for system instrumentation
-      def initialize
-        super(:waterdrop)
-        EVENTS.each(&method(:register_event))
+    # WaterDrop instrumentation monitor that we use to publish events
+    # By default uses our internal notifications bus but can be used with
+    # `ActiveSupport::Notifications` as well
+    class Monitor < ::Karafka::Core::Monitoring::Monitor
+      # @param notifications_bus [Object] either our internal notifications bus or
+      #   `ActiveSupport::Notifications`
+      # @param namespace [String, nil] namespace for events or nil if no namespace
+      def initialize(
+        notifications_bus = WaterDrop::Instrumentation::Notifications.new,
+        namespace = nil
+      )
+        super(notifications_bus, namespace)
       end
     end
   end

data/lib/waterdrop/instrumentation/notifications.rb

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+module WaterDrop
+  module Instrumentation
+    # Instrumented is used to hookup external monitoring services to monitor how WaterDrop works
+    class Notifications < ::Karafka::Core::Monitoring::Notifications
+      # List of events that we support in the system and to which a monitor client can hook up
+      # @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
+        messages.buffered
+
+        buffer.flushed_async
+        buffer.flushed_sync
+
+        statistics.emitted
+
+        error.occurred
+      ].freeze
+
+      private_constant :EVENTS
+
+      # @return [WaterDrop::Instrumentation::Monitor] monitor instance for system instrumentation
+      def initialize
+        super
+        EVENTS.each { |event| register_event(event) }
+      end
+    end
+  end
+end

data/lib/waterdrop/instrumentation/vendors/datadog/listener.rb

@@ -11,26 +11,29 @@ module WaterDrop
         #
         # @note You need to setup the `dogstatsd-ruby` client and assign it
         class Listener
-          include Dry::Configurable
+          include ::Karafka::Core::Configurable
+          extend Forwardable
+
+          def_delegators :config, :client, :rd_kafka_metrics, :namespace, :default_tags
 
           # Value object for storing a single rdkafka metric publishing details
           RdKafkaMetric = Struct.new(:type, :scope, :name, :key_location)
 
           # Namespace under which the DD metrics should be published
-          setting :namespace, default: 'waterdrop', reader: true
+          setting :namespace, default: 'waterdrop'
 
           # Datadog client that we should use to publish the metrics
-          setting :client, reader: true
+          setting :client
 
           # Default tags we want to publish (for example hostname)
           # Format as followed (example for hostname): `["host:#{Socket.gethostname}"]`
-          setting :default_tags, default: [], reader: true
+          setting :default_tags, default: []
 
           # All the rdkafka metrics we want to publish
           #
           # By default we publish quite a lot so this can be tuned
           # Note, that the once with `_d` come from WaterDrop, not rdkafka or Kafka
-          setting :rd_kafka_metrics, reader: true, default: [
+          setting :rd_kafka_metrics, default: [
             # Client metrics
             RdKafkaMetric.new(:count, :root, 'calls', 'tx_d'),
             RdKafkaMetric.new(:histogram, :root, 'queue.size', 'msg_cnt_d'),
@@ -47,8 +50,11 @@ module WaterDrop
             RdKafkaMetric.new(:gauge, :brokers, 'network.latency.p99', %w[rtt p99])
           ].freeze
 
+          configure
+
           # @param block [Proc] configuration block
           def initialize(&block)
+            configure
             setup(&block) if block
           end
 
@@ -60,7 +66,7 @@ module WaterDrop
 
           # Hooks up to WaterDrop instrumentation for emitted statistics
           #
-          # @param event [Dry::Events::Event]
+          # @param event [WaterDrop::Monitor::Event]
           def on_statistics_emitted(event)
             statistics = event[:statistics]
 
@@ -71,22 +77,15 @@ module WaterDrop
 
           # Increases the errors count by 1
           #
-          # @param _event [Dry::Events::Event]
+          # @param _event [WaterDrop::Monitor::Event]
           def on_error_occurred(_event)
-            client.count(
-              namespaced_metric('error_occurred'),
-              1,
-              tags: default_tags
-            )
+            count('error_occurred', 1, tags: default_tags)
           end
 
           # Increases acknowledged messages counter
-          # @param _event [Dry::Events::Event]
+          # @param _event [WaterDrop::Monitor::Event]
           def on_message_acknowledged(_event)
-            client.increment(
-              namespaced_metric('acknowledged'),
-              tags: default_tags
-            )
+            increment('acknowledged', tags: default_tags)
           end
 
           %i[
@@ -94,12 +93,12 @@ module WaterDrop
             produced_async
           ].each do |event_scope|
             class_eval <<~METHODS, __FILE__, __LINE__ + 1
-              # @param event [Dry::Events::Event]
+              # @param event [WaterDrop::Monitor::Event]
               def on_message_#{event_scope}(event)
                 report_message(event[:message][:topic], :#{event_scope})
               end
 
-              # @param event [Dry::Events::Event]
+              # @param event [WaterDrop::Monitor::Event]
               def on_messages_#{event_scope}(event)
                 event[:messages].each do |message|
                   report_message(message[:topic], :#{event_scope})
@@ -114,10 +113,10 @@ module WaterDrop
             messages_buffered
           ].each do |event_scope|
             class_eval <<~METHODS, __FILE__, __LINE__ + 1
-              # @param event [Dry::Events::Event]
+              # @param event [WaterDrop::Monitor::Event]
               def on_#{event_scope}(event)
-                client.histogram(
-                  namespaced_metric('buffer.size'),
+                histogram(
+                  'buffer.size',
                   event[:buffer].size,
                   tags: default_tags
                 )
@@ -132,7 +131,7 @@ module WaterDrop
             flushed_async
           ].each do |event_scope|
             class_eval <<~METHODS, __FILE__, __LINE__ + 1
-              # @param event [Dry::Events::Event]
+              # @param event [WaterDrop::Monitor::Event]
               def on_buffer_#{event_scope}(event)
                 event[:messages].each do |message|
                   report_message(message[:topic], :#{event_scope})
@@ -143,14 +142,28 @@ module WaterDrop
 
           private
 
+          %i[
+            count
+            gauge
+            histogram
+            increment
+            decrement
+          ].each do |metric_type|
+            class_eval <<~METHODS, __FILE__, __LINE__ + 1
+              def #{metric_type}(key, *args)
+                client.#{metric_type}(
+                  namespaced_metric(key),
+                  *args
+                )
+              end
+            METHODS
+          end
+
           # Report that a message has been produced to a topic.
           # @param topic [String] Kafka topic
           # @param method_name [Symbol] method from which this message operation comes
           def report_message(topic, method_name)
-            client.increment(
-              namespaced_metric(method_name),
-              tags: default_tags + ["topic:#{topic}"]
-            )
+            increment(method_name, tags: default_tags + ["topic:#{topic}"])
           end
 
           # Wraps metric name in listener's namespace
@@ -166,9 +179,9 @@ module WaterDrop
           def report_metric(metric, statistics)
             case metric.scope
             when :root
-              client.public_send(
+              public_send(
                 metric.type,
-                namespaced_metric(metric.name),
+                metric.name,
                 statistics.fetch(*metric.key_location),
                 tags: default_tags
               )
@@ -179,9 +192,9 @@ module WaterDrop
                 # node ids
                 next if broker_statistics['nodeid'] == -1
 
-                client.public_send(
+                public_send(
                   metric.type,
-                  namespaced_metric(metric.name),
+                  metric.name,
                   broker_statistics.dig(*metric.key_location),
                   tags: default_tags + ["broker:#{broker_statistics['nodename']}"]
                 )

data/lib/waterdrop/version.rb

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

data/lib/waterdrop.rb

@@ -3,10 +3,8 @@
 # External components
 # delegate should be removed because we don't need it, we just add it because of ruby-kafka
 %w[
-  concurrent/array
-  dry-configurable
-  dry/monitor/notifications
-  dry-validation
+  karafka-core
+  forwardable
   rdkafka
   json
   zeitwerk

data/waterdrop.gemspec

@@ -16,10 +16,7 @@ Gem::Specification.new do |spec|
   spec.description   = spec.summary
   spec.license       = 'MIT'
 
-  spec.add_dependency 'concurrent-ruby', '>= 1.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 'karafka-core', '~> 2.0'
   spec.add_dependency 'rdkafka', '>= 0.10'
   spec.add_dependency 'zeitwerk', '~> 2.3'
 

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: waterdrop
 version: !ruby/object:Gem::Version
-  version: 2.3.1
+  version: 2.4.0
 platform: ruby
 authors:
 - Maciej Mensfeld
@@ -34,64 +34,22 @@ cert_chain:
   R2P11bWoCtr70BsccVrN8jEhzwXngMyI2gVt750Y+dbTu1KgRqZKp/ECe7ZzPzXj
   pIy9vHxTANKYVyI4qj8OrFdEM5BQNu8oQpL0iQ==
   -----END CERTIFICATE-----
-date: 2022-06-17 00:00:00.000000000 Z
+date: 2022-07-28 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
-  name: concurrent-ruby
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '1.1'
-  type: :runtime
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '1.1'
-- !ruby/object:Gem::Dependency
-  name: dry-configurable
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '0.13'
-  type: :runtime
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '0.13'
-- !ruby/object:Gem::Dependency
-  name: dry-monitor
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '0.5'
-  type: :runtime
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '0.5'
-- !ruby/object:Gem::Dependency
-  name: dry-validation
+  name: karafka-core
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '1.7'
+        version: '2.0'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '1.7'
+        version: '2.0'
 - !ruby/object:Gem::Dependency
   name: rdkafka
   requirement: !ruby/object:Gem::Requirement
@@ -145,7 +103,6 @@ files:
 - lib/waterdrop.rb
 - lib/waterdrop/config.rb
 - lib/waterdrop/contracts.rb
-- lib/waterdrop/contracts/base.rb
 - lib/waterdrop/contracts/config.rb
 - lib/waterdrop/contracts/message.rb
 - lib/waterdrop/errors.rb
@@ -157,6 +114,7 @@ files:
 - lib/waterdrop/instrumentation/callbacks_manager.rb
 - lib/waterdrop/instrumentation/logger_listener.rb
 - 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/patches/rdkafka/bindings.rb
@@ -192,7 +150,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.2.20
+rubygems_version: 3.3.7
 signing_key: 
 specification_version: 4
 summary: Kafka messaging made easy!

metadata.gz.sig

@@ -1 +1,5 @@
-Ӑ�v�ij(��.kzT���MK�����u����QYH�\���ú�pt��:,;e�a��hU��B֬�j����k�>I��č+�����4�!;�C��[�j2�d����¢��h�����q�^��_�*D��O�9���A�G��?+ҏF���Wq�@"i���E�iM��� �b�OnS�})w#�
+�D�T�[_g4r0Z���r�-(�� �d����$��HM��]��2�0��9�� D;�98@�.���\$ߝ0�Kn&�l��]��%�
+#9xg�j��OZ�tCp�4��ҥ��[��r�
+@~�5��/9��_'������0k��'-@G���������c�[":�jh�9]����^��i]�8�x�'tR���z^�@�f�n��O�!��ؗ����
+B��$Il�J�ۺE'����,���=��>ǡ��k�j�Pڪ'�[\���]��;̧��ԏ
+iB&U��z�1_���k���B�*�}])

data/lib/waterdrop/contracts/base.rb

@@ -1,23 +0,0 @@
-# frozen_string_literal: true
-
-module WaterDrop
-  module Contracts
-    # Base for all the contracts in WaterDrop
-    class Base < Dry::Validation::Contract
-      config.messages.load_paths << File.join(WaterDrop.gem_root, 'config', 'errors.yml')
-
-      # @param data [Hash] data for validation
-      # @param error_class [Class] error class that should be used when validation fails
-      # @return [Boolean] true
-      # @raise [StandardError] any error provided in the error_class that inherits from the
-      #   standard error
-      def validate!(data, error_class)
-        result = call(data)
-
-        return true if result.success?
-
-        raise error_class, result.errors.to_h
-      end
-    end
-  end
-end