waterdrop 1.4.3 → 2.0.0.rc1

data/lib/water_drop/base_producer.rb

@@ -1,57 +0,0 @@
-# frozen_string_literal: true
-
-module WaterDrop
-  # Base messages producer that contains all the logic that is exactly the same for both
-  # sync and async producers
-  class BaseProducer
-    # Contract for checking the correctness of the provided data that someone wants to
-    # dispatch to Kafka
-    SCHEMA = Contracts::MessageOptions.new.freeze
-
-    private_constant :SCHEMA
-
-    class << self
-      private
-
-      # Runs the message options validations and raises an error if anything is invalid
-      # @param options [Hash] hash that we want to validate
-      # @raise [WaterDrop::Errors::InvalidMessageOptions] raised when message options are
-      #   somehow invalid and we cannot perform delivery because of that
-      def validate!(options)
-        validation_result = SCHEMA.call(options)
-        return true if validation_result.success?
-
-        raise Errors::InvalidMessageOptions, validation_result.errors
-      end
-
-      # Upon failed delivery, we may try to resend a message depending on the attempt number
-      #   or re-raise an error if we're unable to do that after given number of retries
-      #   This method checks that and also instruments errors and retries for the delivery
-      # @param attempts_count [Integer] number of attempt (starting from 1) for the delivery
-      # @param message [String] message that we want to send to Kafka
-      # @param options [Hash] options (including topic) for producer
-      # @param error [Kafka::Error] error that occurred
-      # @return [Boolean] true if this is a graceful attempt and we can retry or false it this
-      #   was the final one and we should deal with the fact, that we cannot deliver a given
-      #   message
-      def graceful_attempt?(attempts_count, message, options, error)
-        scope = "#{to_s.split('::').last.sub('Producer', '_producer').downcase}.call"
-        payload = {
-          caller: self,
-          message: message,
-          options: options,
-          error: error,
-          attempts_count: attempts_count
-        }
-
-        if attempts_count > WaterDrop.config.kafka.max_retries
-          WaterDrop.monitor.instrument("#{scope}.error", payload)
-          false
-        else
-          WaterDrop.monitor.instrument("#{scope}.retry", payload)
-          true
-        end
-      end
-    end
-  end
-end

data/lib/water_drop/config_applier.rb

@@ -1,52 +0,0 @@
-# frozen_string_literal: true
-
-module WaterDrop
-  # Engine used to propagate config application to DeliveryBoy with corner case handling
-  module ConfigApplier
-    class << self
-      # @param delivery_boy_config [DeliveryBoy::Config] delivery boy config instance
-      # @param settings [Hash] hash with WaterDrop settings
-      def call(delivery_boy_config, settings)
-        # Recursive lambda for mapping config down to delivery boy
-        settings.each do |key, value|
-          call(delivery_boy_config, value) && next if value.is_a?(Hash)
-
-          # If this is a special case that needs manual setup instead of a direct reassignment
-          if respond_to?(key, true)
-            send(key, delivery_boy_config, value)
-          else
-            # If this setting is our internal one, we should not sync it with the delivery boy
-            next unless delivery_boy_config.respond_to?(:"#{key}=")
-
-            delivery_boy_config.public_send(:"#{key}=", value)
-          end
-        end
-      end
-
-      private
-
-      # Extra setup for the compression codec as it behaves differently than other settings
-      # that are ported 1:1 from ruby-kafka
-      # For some crazy reason, delivery boy requires compression codec as a string, when
-      # ruby-kafka as a symbol. We follow ruby-kafka internal design, so we had to mimic
-      # that by assigning a string version that down the road will be symbolized again
-      # by delivery boy
-      # @param delivery_boy_config [DeliveryBoy::Config] delivery boy config instance
-      # @param codec_name [Symbol] codec name as a symbol
-      def compression_codec(delivery_boy_config, codec_name)
-        # If there is no compression codec, we don't apply anything
-        return unless codec_name
-
-        delivery_boy_config.compression_codec = codec_name.to_s
-      end
-
-      # We use the "seed_brokers" name and DeliveryBoy uses "brokers" so we pass the values
-      #   manually
-      # @param delivery_boy_config [DeliveryBoy::Config] delivery boy config instance
-      # @param seed_brokers [Array<String>] kafka seed brokers
-      def seed_brokers(delivery_boy_config, seed_brokers)
-        delivery_boy_config.brokers = seed_brokers
-      end
-    end
-  end
-end

data/lib/water_drop/contracts/message_options.rb

@@ -1,19 +0,0 @@
-# frozen_string_literal: true
-
-module WaterDrop
-  module Contracts
-    # Contract with validation rules for validating that all the message options that
-    # we provide to producer ale valid and usable
-    # @note Does not validate message itself as it is not our concern
-    class MessageOptions < Dry::Validation::Contract
-      params do
-        required(:topic).filled(:str?, format?: TOPIC_REGEXP)
-        optional(:key).maybe(:str?, :filled?)
-        optional(:partition).filled(:int?, gteq?: 0)
-        optional(:partition_key).maybe(:str?, :filled?)
-        optional(:create_time).maybe(:time?)
-        optional(:headers).maybe(:hash?)
-      end
-    end
-  end
-end

data/lib/water_drop/sync_producer.rb

@@ -1,24 +0,0 @@
-# frozen_string_literal: true
-
-# WaterDrop library
-module WaterDrop
-  # Sync producer for messages
-  class SyncProducer < BaseProducer
-    # Performs message delivery using deliver_async method
-    # @param message [String] message that we want to send to Kafka
-    # @param options [Hash] options (including topic) for producer
-    # @raise [WaterDrop::Errors::InvalidMessageOptions] raised when message options are
-    #   somehow invalid and we cannot perform delivery because of that
-    def self.call(message, options)
-      attempts_count ||= 0
-      attempts_count += 1
-
-      validate!(options)
-      return unless WaterDrop.config.deliver
-
-      DeliveryBoy.deliver(message, **options)
-    rescue Kafka::Error => e
-      graceful_attempt?(attempts_count, message, options, e) ? retry : raise(e)
-    end
-  end
-end