waterdrop 2.8.14 → 2.8.16

data/bin/integrations

@@ -4,14 +4,14 @@
 
 # All integration specs run with their own bundler context to avoid dependency conflicts.
 # All WaterDrop integration specs are pristine by default since they use isolated Gemfiles.
-raise 'This code needs to be executed WITHOUT bundle exec' if Kernel.const_defined?(:Bundler)
+raise "This code needs to be executed WITHOUT bundle exec" if Kernel.const_defined?(:Bundler)
 
-require 'open3'
-require 'fileutils'
-require 'pathname'
-require 'tmpdir'
+require "open3"
+require "fileutils"
+require "pathname"
+require "tmpdir"
 
-ROOT_PATH = Pathname.new(File.expand_path(File.join(File.dirname(__FILE__), '../')))
+ROOT_PATH = Pathname.new(File.expand_path(File.join(File.dirname(__FILE__), "../")))
 
 # How may bytes do we want to keep from the stdout in the buffer for when we need to print it
 MAX_BUFFER_OUTPUT = 307_200
@@ -36,9 +36,9 @@ class Scenario
   def initialize(path)
     @path = path
     # First 1024 characters from stdout
-    @stdout_head = ''
+    @stdout_head = ""
     # Last 1024 characters from stdout
-    @stdout_tail = ''
+    @stdout_tail = ""
   end
 
   # Starts running given scenario in a separate process
@@ -49,16 +49,15 @@ class Scenario
 
   # @return [String] integration spec name
   def name
-    @path.gsub("#{ROOT_PATH}/spec/integrations/", '')
+    @path.gsub("#{ROOT_PATH}/spec/integrations/", "")
   end
 
-
   # @return [Boolean] did this scenario finished or is it still running
   def finished?
     # If the thread is running too long, kill it
     if current_time - @started_at > MAX_RUN_TIME
       begin
-        Process.kill('TERM', pid)
+        Process.kill("TERM", pid)
       # It may finish right after we want to kill it, that's why we ignore this
       rescue Errno::ESRCH
       end
@@ -66,7 +65,7 @@ class Scenario
 
     # We read it so it won't grow as we use our default logger that prints to both test.log and
     # to stdout. Otherwise after reaching the buffer size, it would hang
-    buffer = ''
+    buffer = ""
     @stdout.read_nonblock(MAX_BUFFER_OUTPUT, buffer, exception: false)
     @stdout_head = buffer if @stdout_head.empty?
     @stdout_tail << buffer
@@ -101,19 +100,19 @@ class Scenario
   # Prints a status report when scenario is finished and stdout if it failed
   def report
     if success?
-      print "\e[#{32}m#{'.'}\e[0m"
+      print "\e[32m.\e[0m"
     else
-      buffer = ''
+      buffer = ""
 
       @stderr.read_nonblock(MAX_BUFFER_OUTPUT, buffer, exception: false)
 
       puts
-      puts "\e[#{31}m#{'[FAILED]'}\e[0m #{name}"
+      puts "\e[31m[FAILED]\e[0m #{name}"
       puts "Time taken: #{current_time - @started_at} seconds"
       puts "Exit code: #{exit_code}"
       puts "Exit status: #{exit_status}"
       puts @stdout_head
-      puts '...'
+      puts "..."
       puts @stdout_tail
       puts buffer
       puts
@@ -163,38 +162,38 @@ class Scenario
 end
 
 # Load all the specs
-specs = Dir[ROOT_PATH.join('spec/integrations/**/*_spec.rb')]
+specs = Dir[ROOT_PATH.join("spec/integrations/**/*_spec.rb")]
 
-FILTER_TYPE = ARGV[0] == '--exclude' ? 'exclude' : 'include'
+FILTER_TYPE = (ARGV[0] == "--exclude") ? "exclude" : "include"
 
 # Remove the exclude flag
-ARGV.shift if FILTER_TYPE == '--exclude'
+ARGV.shift if FILTER_TYPE == "--exclude"
 
 # If filters is provided, apply
 # Allows to provide several filters one after another and applies all of them
 ARGV.each do |filter|
   specs.delete_if do |name|
     case FILTER_TYPE
-    when 'include'
+    when "include"
       !name.include?(filter)
-    when 'exclude'
+    when "exclude"
       name.include?(filter)
     else
-      raise 'Invalid filter type'
+      raise "Invalid filter type"
     end
   end
 end
 
 # Randomize order
-seed = (ENV['SPECS_SEED'] || rand(0..10_000)).to_i
+seed = (ENV["SPECS_SEED"] || rand(0..10_000)).to_i
 
 puts "Random seed: #{seed}"
 
 scenarios = specs
-            .shuffle(random: Random.new(seed))
-            .map { |integration| Scenario.new(integration) }
+  .shuffle(random: Random.new(seed))
+  .map { |integration| Scenario.new(integration) }
 
-raise ArgumentError, "No integration specs with filters: #{ARGV.join(', ')}" if scenarios.empty?
+raise ArgumentError, "No integration specs with filters: #{ARGV.join(", ")}" if scenarios.empty?
 
 puts "Running #{scenarios.size} scenarios"
 
@@ -217,8 +216,8 @@ end
 puts
 puts "\nLongest scenarios:\n\n"
 
-finished_scenarios.sort_by(&:time_taken).reverse.first(10).each do |long_scenario|
-  puts "[#{'%6.2f' % long_scenario.time_taken}] #{long_scenario.name}"
+finished_scenarios.sort_by(&:time_taken).last(10).reverse_each do |long_scenario|
+  puts "[#{"%6.2f" % long_scenario.time_taken}] #{long_scenario.name}"
 end
 
 failed_scenarios = finished_scenarios.reject(&:success?)
@@ -232,7 +231,7 @@ else
   puts "\nFailed scenarios:\n\n"
 
   failed_scenarios.each do |scenario|
-    puts "\e[#{31}m#{'[FAILED]'}\e[0m #{scenario.name}"
+    puts "\e[31m[FAILED]\e[0m #{scenario.name}"
   end
 
   puts

data/bin/verify_topics_naming

@@ -8,18 +8,18 @@
 #
 # It also ensures we have one convention that we can follow.
 
-require 'bundler'
+require "bundler"
 Bundler.setup(:default, :test, :integrations)
-require 'rdkafka'
+require "rdkafka"
 
-admin = Rdkafka::Config.new('bootstrap.servers': 'localhost:9092').admin
+admin = Rdkafka::Config.new("bootstrap.servers": "localhost:9092").admin
 
 invalid = admin
-          .metadata
-          .topics
-          .map { |topic| topic[:topic_name] }
-          .select { |topic| !topic.start_with?('it-') }
-          .select { |topic| topic.length <= 6 }
+  .metadata
+  .topics
+  .map { |topic| topic[:topic_name] }
+  .select { |topic| !topic.start_with?("it-") }
+  .select { |topic| topic.length <= 6 }
 
 admin.close
 

data/config/locales/errors.yml

@@ -26,6 +26,18 @@ en:
       non_reloadable_errors_format: must be an array of symbols
       oauth.token_provider_listener_format: 'must be false or respond to #on_oauthbearer_token_refresh'
       idle_disconnect_timeout_format: 'must be an integer that is equal to 0 or bigger than 30 000 (30 seconds)'
+      polling.mode_format: must be :thread or :fd
+      polling.poller_format: must be nil or a WaterDrop::Polling::Poller instance
+      polling.poller_poller_only_with_fd_mode: can only be set when polling.mode is :fd
+      polling.fd.max_time_format: must be an integer that is equal or bigger than 1
+      polling.fd.periodic_poll_interval_format: must be an integer that is equal or bigger than 1
+
+    poller:
+      thread_priority_format: must be an integer between -3 and 3
+      poll_timeout_format: must be an integer that is equal or bigger than 1
+      backoff_min_format: must be an integer that is equal or bigger than 1
+      backoff_max_format: must be an integer that is equal or bigger than 1
+      backoff_max_must_be_gte_backoff_min: backoff_max must be greater than or equal to backoff_min
 
     variant:
       missing: must be present

data/docker-compose.oauth.yml

@@ -0,0 +1,56 @@
+services:
+  keycloak:
+    image: quay.io/keycloak/keycloak:26.5
+    container_name: keycloak
+    command: start-dev --import-realm
+    ports:
+      - "8080:8080"
+    environment:
+      KEYCLOAK_ADMIN: admin
+      KEYCLOAK_ADMIN_PASSWORD: admin
+    volumes:
+      - ./spec/integrations/oauth_token_refresh/keycloak-realm.json:/opt/keycloak/data/import/realm.json
+    healthcheck:
+      test: ["CMD-SHELL", "exec 3<>/dev/tcp/localhost/8080 && echo -e 'GET /realms/kafka HTTP/1.1\\r\\nHost: localhost\\r\\n\\r\\n' >&3 && timeout 1 cat <&3 | grep -q '200 OK'"]
+      interval: 10s
+      timeout: 10s
+      retries: 30
+      start_period: 90s
+
+  kafka-oauth:
+    image: confluentinc/cp-kafka:8.1.1
+    container_name: kafka-oauth
+    depends_on:
+      keycloak:
+        condition: service_healthy
+    ports:
+      - "9094:9094"
+    environment:
+      CLUSTER_ID: kafka-oauth-cluster-1
+      KAFKA_BROKER_ID: 1
+      KAFKA_PROCESS_ROLES: broker,controller
+      KAFKA_CONTROLLER_QUORUM_VOTERS: 1@kafka-oauth:9093
+      KAFKA_CONTROLLER_LISTENER_NAMES: CONTROLLER
+      KAFKA_INTER_BROKER_LISTENER_NAME: PLAINTEXT
+      KAFKA_LISTENERS: PLAINTEXT://:9092,CONTROLLER://:9093,SASL_PLAINTEXT://:9094
+      KAFKA_ADVERTISED_LISTENERS: PLAINTEXT://kafka-oauth:9092,SASL_PLAINTEXT://127.0.0.1:9094
+      KAFKA_LISTENER_SECURITY_PROTOCOL_MAP: CONTROLLER:PLAINTEXT,PLAINTEXT:PLAINTEXT,SASL_PLAINTEXT:SASL_PLAINTEXT
+      KAFKA_SASL_ENABLED_MECHANISMS: OAUTHBEARER
+      KAFKA_SASL_MECHANISM_INTER_BROKER_PROTOCOL: PLAINTEXT
+      # Per-listener callback handler
+      KAFKA_LISTENER_NAME_SASL__PLAINTEXT_OAUTHBEARER_SASL_SERVER_CALLBACK_HANDLER_CLASS: org.apache.kafka.common.security.oauthbearer.OAuthBearerValidatorCallbackHandler
+      KAFKA_LISTENER_NAME_SASL__PLAINTEXT_OAUTHBEARER_SASL_JAAS_CONFIG: |
+        org.apache.kafka.common.security.oauthbearer.OAuthBearerLoginModule required;
+      # Global OAUTHBEARER settings for token validation
+      KAFKA_SASL_OAUTHBEARER_JWKS_ENDPOINT_URL: http://keycloak:8080/realms/kafka/protocol/openid-connect/certs
+      KAFKA_SASL_OAUTHBEARER_EXPECTED_AUDIENCE: kafka
+      # Note: Not setting expected issuer - Keycloak uses request URL which varies
+      KAFKA_AUTO_CREATE_TOPICS_ENABLE: "true"
+      KAFKA_OFFSETS_TOPIC_REPLICATION_FACTOR: 1
+      KAFKA_TRANSACTION_STATE_LOG_REPLICATION_FACTOR: 1
+      KAFKA_TRANSACTION_STATE_LOG_MIN_ISR: 1
+      # Required by Confluent image when SASL is enabled
+      # Also allow HTTP URLs for JWKS endpoint (Kafka 3.0+ blocks non-HTTPS by default)
+      KAFKA_OPTS: "-Djava.security.auth.login.config=/etc/kafka/kafka_server_jaas.conf -Dorg.apache.kafka.sasl.oauthbearer.allowed.urls=http://keycloak:8080/realms/kafka/protocol/openid-connect/certs"
+    volumes:
+      - ./spec/integrations/oauth_token_refresh/kafka_server_jaas.conf:/etc/kafka/kafka_server_jaas.conf:ro

data/docker-compose.yml

@@ -1,7 +1,7 @@
 services:
   kafka:
     container_name: kafka
-    image: confluentinc/cp-kafka:8.0.0
+    image: confluentinc/cp-kafka:8.1.1
 
     ports:
       - 9092:9092

data/lib/waterdrop/clients/dummy.rb

@@ -57,6 +57,15 @@ module WaterDrop
         Handle.new(topic.to_s, partition, @counters["#{topic}#{partition}"] += 1)
       end
 
+      # Returns 0 as dummy client doesn't queue any real messages
+      #
+      # @return [Integer] always 0
+      def queue_size
+        0
+      end
+
+      alias_method :queue_length, :queue_size
+
       # @param _args [Object] anything really, this dummy is suppose to support anything
       def respond_to_missing?(*_args)
         true

data/lib/waterdrop/clients/rdkafka.rb

@@ -14,7 +14,13 @@ module WaterDrop
           kafka_config = producer.config.kafka.to_h
           monitor = producer.config.monitor
 
-          client = ::Rdkafka::Config.new(kafka_config).producer(native_kafka_auto_start: false)
+          # 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 = ::Rdkafka::Config.new(kafka_config).producer(**producer_options)
 
           # Register statistics runner for this particular type of callbacks
           ::Karafka::Core::Instrumentation.statistics_callbacks.add(
@@ -53,8 +59,13 @@ module WaterDrop
 
           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
+          producer.poller.register(producer, client) if producer.fd_polling?
+
           # Switch to the transactional mode if user provided the transactional id
-          client.init_transactions if kafka_config.key?(:'transactional.id')
+          client.init_transactions if kafka_config.key?(:"transactional.id")
 
           client
         end

data/lib/waterdrop/config.rb

@@ -9,18 +9,18 @@ module WaterDrop
 
     # Defaults for kafka settings, that will be overwritten only if not present already
     KAFKA_DEFAULTS = {
-      'client.id': 'waterdrop',
+      "client.id": "waterdrop",
       # emit librdkafka statistics every five seconds. This is used in instrumentation.
       # When disabled, part of metrics will not be published and available.
-      'statistics.interval.ms': 5_000,
+      "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": 50_000,
       # Must be more or equal to `message.timeout.ms` defaults
-      'transaction.timeout.ms': 55_000,
+      "transaction.timeout.ms": 55_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
+      "socket.nagle.disable": true
     }.freeze
 
     private_constant :KAFKA_DEFAULTS
@@ -140,6 +140,33 @@ module WaterDrop
       setting :token_provider_listener, default: false
     end
 
+    # 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
+
+      # option [WaterDrop::Polling::Poller, nil] Custom poller instance for isolation
+      # When nil (default), uses the global singleton poller shared by all FD-mode producers
+      # When set to a Poller instance, uses that dedicated poller for this producer only
+      # This allows isolating producers from each other's callback processing
+      # Only valid when mode is :fd
+      setting :poller, default: nil
+
+      # Namespace for FD-based polling configuration (only used when mode is :fd)
+      setting :fd do
+        # option [Integer] Max milliseconds to poll a single producer before rotating to the next
+        # This prevents any single producer from monopolizing the polling thread
+        setting :max_time, default: 100
+
+        # option [Integer] Interval in milliseconds for periodic polling of idle producers
+        # When one producer is busy, other producers still need to be polled periodically
+        # to ensure OAuth token refresh and statistics callbacks fire on time
+        setting :periodic_poll_interval, default: 1_000
+      end
+    end
+
     # Configuration method
     # @yield Runs a block of code providing a config singleton instance to it
     # @yieldparam [WaterDrop::Config] WaterDrop config instance

data/lib/waterdrop/connection_pool.rb

@@ -42,6 +42,8 @@ module WaterDrop
 
     class << self
       # Global connection pool instance
+      # @!attribute [rw] default_pool
+      #   @return [ConnectionPool, nil] the global connection pool instance
       attr_accessor :default_pool
 
       # Sets up a global connection pool
@@ -73,7 +75,7 @@ module WaterDrop
 
         # Emit global event for pool setup
         WaterDrop.instrumentation.instrument(
-          'connection_pool.setup',
+          "connection_pool.setup",
           pool: @default_pool,
           size: size,
           timeout: timeout
@@ -93,7 +95,7 @@ module WaterDrop
       #     producer.produce_sync(topic: 'events', payload: 'data')
       #   end
       def with(...)
-        raise 'No global connection pool configured. Call setup first.' unless @default_pool
+        raise "No global connection pool configured. Call setup first." unless @default_pool
 
         @default_pool.with(...)
       end
@@ -120,7 +122,7 @@ module WaterDrop
 
         # Emit global event for pool shutdown
         WaterDrop.instrumentation.instrument(
-          'connection_pool.shutdown',
+          "connection_pool.shutdown",
           pool: pool
         )
       end
@@ -128,7 +130,7 @@ module WaterDrop
       # Alias for shutdown to align with producer API
       # WaterDrop producers use #close, so we alias connection pool #shutdown to #close
       # for API consistency across both individual producers and connection pools
-      alias close shutdown
+      alias_method :close, :shutdown
 
       # Reload the global connection pool
       def reload
@@ -138,7 +140,7 @@ module WaterDrop
 
         # Emit global event for pool reload
         WaterDrop.instrumentation.instrument(
-          'connection_pool.reload',
+          "connection_pool.reload",
           pool: @default_pool
         )
       end
@@ -163,7 +165,7 @@ module WaterDrop
       #     producer.produce(topic: 'events', payload: 'data2')
       #   end
       def transaction(...)
-        raise 'No global connection pool configured. Call setup first.' unless @default_pool
+        raise "No global connection pool configured. Call setup first." unless @default_pool
 
         @default_pool.transaction(...)
       end
@@ -175,7 +177,7 @@ module WaterDrop
       def ensure_connection_pool_gem!
         return if defined?(::ConnectionPool)
 
-        require 'connection_pool'
+        require "connection_pool"
       rescue LoadError
         raise LoadError, <<~ERROR
           WaterDrop::ConnectionPool requires the 'connection_pool' gem.
@@ -217,7 +219,7 @@ module WaterDrop
 
       # Emit event when a connection pool is created
       WaterDrop.instrumentation.instrument(
-        'connection_pool.created',
+        "connection_pool.created",
         pool: self,
         size: size,
         timeout: timeout
@@ -242,7 +244,7 @@ module WaterDrop
 
       # Emit event after pool is shut down
       WaterDrop.instrumentation.instrument(
-        'connection_pool.shutdown',
+        "connection_pool.shutdown",
         pool: self
       )
     end
@@ -250,7 +252,7 @@ module WaterDrop
     # Alias for shutdown to align with producer API
     # WaterDrop producers use #close, so we alias connection pool #shutdown to #close
     # for API consistency across both individual producers and connection pools
-    alias close shutdown
+    alias_method :close, :shutdown
 
     # Reload all connections in the pool
     # Useful for configuration changes or error recovery
@@ -261,7 +263,7 @@ module WaterDrop
 
       # Emit event after pool is reloaded
       WaterDrop.instrumentation.instrument(
-        'connection_pool.reloaded',
+        "connection_pool.reloaded",
         pool: self
       )
     end

data/lib/waterdrop/contracts/config.rb

@@ -6,8 +6,8 @@ module WaterDrop
     class Config < ::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('config')
+          File.join(WaterDrop.gem_root, "config", "locales", "errors.yml")
+        ).fetch("en").fetch("validations").fetch("config")
       end
 
       required(:id) { |val| val.is_a?(String) && !val.empty? }
@@ -43,16 +43,40 @@ module WaterDrop
         end
       end
 
+      nested(:polling) do
+        required(:mode) { |val| %i[thread fd].include?(val) }
+        required(:poller) { |val| val.nil? || val.is_a?(Polling::Poller) }
+
+        nested(:fd) do
+          required(:max_time) { |val| val.is_a?(Integer) && val >= 1 }
+          required(:periodic_poll_interval) { |val| val.is_a?(Integer) && val >= 100 }
+        end
+      end
+
+      # Validate that poller is only set when mode is :fd
+      virtual do |config, errors|
+        next true unless errors.empty?
+
+        polling = config.fetch(:polling)
+        mode = polling.fetch(:mode)
+        poller = polling.fetch(:poller)
+
+        next true if poller.nil?
+        next true if mode == :fd
+
+        [[%i[polling poller], :poller_only_with_fd_mode]]
+      end
+
       # 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
       virtual do |config, errors|
         next true unless errors.empty?
 
         errors = config
-                 .fetch(:kafka)
-                 .keys
-                 .reject { |key| key.is_a?(Symbol) }
-                 .map { |key| [[:kafka, key], :kafka_key_must_be_a_symbol] }
+          .fetch(:kafka)
+          .keys
+          .reject { |key| key.is_a?(Symbol) }
+          .map { |key| [[:kafka, key], :kafka_key_must_be_a_symbol] }
 
         errors
       end

data/lib/waterdrop/contracts/message.rb

@@ -7,8 +7,8 @@ module WaterDrop
     class Message < ::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('message')
+          File.join(WaterDrop.gem_root, "config", "locales", "errors.yml")
+        ).fetch("en").fetch("validations").fetch("message")
       end
 
       # Regex to check that topic has a valid format

data/lib/waterdrop/contracts/poller_config.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+module WaterDrop
+  module Contracts
+    # Contract with validation rules for WaterDrop Poller configuration
+    class PollerConfig < ::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("poller")
+      end
+
+      required(:thread_priority) { |val| val.is_a?(Integer) && val >= -3 && val <= 3 }
+      required(:poll_timeout) { |val| val.is_a?(Integer) && val >= 1 }
+      required(:backoff_min) { |val| val.is_a?(Integer) && val >= 1 }
+      required(:backoff_max) { |val| val.is_a?(Integer) && val >= 1 }
+
+      virtual do |config, errors|
+        next true unless errors.empty?
+        next true if config[:backoff_max] >= config[:backoff_min]
+
+        [[%i[backoff_max], :backoff_max_must_be_gte_backoff_min]]
+      end
+    end
+  end
+end

data/lib/waterdrop/contracts/transactional_offset.rb

@@ -7,8 +7,8 @@ module WaterDrop
     class TransactionalOffset < ::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('transactional_offset')
+          File.join(WaterDrop.gem_root, "config", "locales", "errors.yml")
+        ).fetch("en").fetch("validations").fetch("transactional_offset")
       end
 
       required(:consumer) { |val| val.respond_to?(:consumer_group_metadata_pointer) }

data/lib/waterdrop/contracts/variant.rb

@@ -28,8 +28,8 @@ module WaterDrop
 
       configure do |config|
         config.error_messages = YAML.safe_load_file(
-          File.join(WaterDrop.gem_root, 'config', 'locales', 'errors.yml')
-        ).fetch('en').fetch('validations').fetch('variant')
+          File.join(WaterDrop.gem_root, "config", "locales", "errors.yml")
+        ).fetch("en").fetch("validations").fetch("variant")
       end
 
       required(:default) { |val| BOOLEANS.include?(val) }
@@ -40,10 +40,10 @@ module WaterDrop
         next true unless errors.empty?
 
         errors = config
-                 .fetch(:topic_config)
-                 .keys
-                 .reject { |key| key.is_a?(Symbol) }
-                 .map { |key| [[:kafka, key], :kafka_key_must_be_a_symbol] }
+          .fetch(:topic_config)
+          .keys
+          .reject { |key| key.is_a?(Symbol) }
+          .map { |key| [[:kafka, key], :kafka_key_must_be_a_symbol] }
 
         errors
       end
@@ -53,10 +53,10 @@ module WaterDrop
         next true unless errors.empty?
 
         errors = config
-                 .fetch(:topic_config)
-                 .keys
-                 .reject { |key| TOPIC_CONFIG_KEYS.include?(key) }
-                 .map { |key| [[:kafka, key], :kafka_key_not_per_topic] }
+          .fetch(:topic_config)
+          .keys
+          .reject { |key| TOPIC_CONFIG_KEYS.include?(key) }
+          .map { |key| [[:kafka, key], :kafka_key_not_per_topic] }
 
         errors
       end
@@ -70,10 +70,10 @@ module WaterDrop
         next true unless config.fetch(:transactional)
 
         errors = config
-                 .fetch(:topic_config)
-                 .keys
-                 .select { |key| key.to_s.include?('acks') }
-                 .map { |key| [[:kafka, key], :kafka_key_acks_not_changeable] }
+          .fetch(:topic_config)
+          .keys
+          .select { |key| key.to_s.include?("acks") }
+          .map { |key| [[:kafka, key], :kafka_key_acks_not_changeable] }
 
         errors
       end
@@ -85,10 +85,10 @@ module WaterDrop
         next true unless config.fetch(:idempotent)
 
         errors = config
-                 .fetch(:topic_config)
-                 .keys
-                 .select { |key| key.to_s.include?('acks') }
-                 .map { |key| [[:kafka, key], :kafka_key_acks_not_changeable] }
+          .fetch(:topic_config)
+          .keys
+          .select { |key| key.to_s.include?("acks") }
+          .map { |key| [[:kafka, key], :kafka_key_acks_not_changeable] }
 
         errors
       end