karafka 2.5.1 → 2.5.3

data/lib/karafka/active_job/current_attributes.rb

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
 require 'active_support/current_attributes'
+require_relative 'current_attributes/job_wrapper'
 require_relative 'current_attributes/loading'
 require_relative 'current_attributes/persistence'
 
@@ -22,8 +23,8 @@ module Karafka
           .each { |expandable| expandable.class_attribute :_cattr_klasses, default: {} }
 
         # Do not double inject in case of running persist multiple times
-        Dispatcher.prepend(Persistence) unless Dispatcher.ancestors.include?(Persistence)
-        Consumer.prepend(Loading) unless Consumer.ancestors.include?(Loading)
+        Dispatcher.prepend(Persistence) unless Dispatcher <= Persistence
+        Consumer.prepend(Loading) unless Consumer <= Loading
 
         klasses.map(&:to_s).each do |stringified_klass|
           # Prevent registering same klass multiple times

data/lib/karafka/active_job/deserializer.rb

@@ -0,0 +1,61 @@
+# frozen_string_literal: true
+
+module Karafka
+  module ActiveJob
+    # Default deserializer for ActiveJob jobs
+    #
+    # @note Despite the name, this class handles both serialization (job to Kafka payload) and
+    #   deserialization (Kafka message to job). It's called "Deserializer" to align with Karafka's
+    #   naming conventions where message consumption is the primary concern.
+    #
+    # This class can be inherited and its methods can be overridden to support
+    # custom payload formats (e.g., Avro, Protobuf, MessagePack)
+    #
+    # @example Wrapping jobs in a custom envelope with metadata
+    #   class EnvelopedJobDeserializer < Karafka::ActiveJob::Deserializer
+    #     def serialize(job)
+    #       # Wrap the job in an envelope with additional metadata
+    #       envelope = {
+    #         version: 1,
+    #         produced_at: Time.now.iso8601,
+    #         producer: 'my-app',
+    #         payload: job.serialize
+    #       }
+    #       ::ActiveSupport::JSON.encode(envelope)
+    #     end
+    #
+    #     def deserialize(message)
+    #       # Extract the job from the envelope
+    #       envelope = ::ActiveSupport::JSON.decode(message.raw_payload)
+    #
+    #       # Could validate envelope version, log metadata, etc.
+    #       raise 'Unsupported version' if envelope['version'] != 1
+    #
+    #       # Return the actual job data
+    #       envelope['payload']
+    #     end
+    #   end
+    #
+    #   # Configure in Karafka
+    #   Karafka::App.config.internal.active_job.deserializer = EnvelopedJobDeserializer.new
+    class Deserializer
+      # Serializes an ActiveJob job into a string payload for Kafka
+      #
+      # @param job [ActiveJob::Base, #serialize] job to serialize. The job must respond to
+      #   #serialize which returns a Hash of job attributes. When CurrentAttributes are used,
+      #   this may be a JobWrapper instance instead of the original ::ActiveJob::Base.
+      # @return [String] serialized job payload
+      def serialize(job)
+        ::ActiveSupport::JSON.encode(job.serialize)
+      end
+
+      # Deserializes a Kafka message payload into an ActiveJob job hash
+      #
+      # @param message [Karafka::Messages::Message] message containing the job
+      # @return [Hash] deserialized job hash
+      def deserialize(message)
+        ::ActiveSupport::JSON.decode(message.raw_payload)
+      end
+    end
+  end
+end

data/lib/karafka/active_job/dispatcher.rb

@@ -4,6 +4,10 @@ module Karafka
   module ActiveJob
     # Dispatcher that sends the ActiveJob job to a proper topic based on the queue name
     class Dispatcher
+      include Helpers::ConfigImporter.new(
+        deserializer: %i[internal active_job deserializer]
+      )
+
       # Defaults for dispatching
       # The can be updated by using `#karafka_options` on the job
       DEFAULTS = {
@@ -15,10 +19,10 @@ module Karafka
 
       # @param job [ActiveJob::Base] job
       def dispatch(job)
-        ::Karafka.producer.public_send(
+        Karafka.producer.public_send(
           fetch_option(job, :dispatch_method, DEFAULTS),
           topic: job.queue_name,
-          payload: ::ActiveSupport::JSON.encode(serialize_job(job))
+          payload: serialize_job(job)
         )
       end
 
@@ -34,12 +38,12 @@ module Karafka
 
           dispatches[d_method] << {
             topic: job.queue_name,
-            payload: ::ActiveSupport::JSON.encode(serialize_job(job))
+            payload: serialize_job(job)
           }
         end
 
         dispatches.each do |type, messages|
-          ::Karafka.producer.public_send(
+          Karafka.producer.public_send(
             type,
             messages
           )
@@ -48,14 +52,18 @@ module Karafka
 
       # Raises info, that Karafka backend does not support scheduling jobs if someone wants to
       # schedule jobs in the future. It works for past and present because we want to support
-      # things like continuation and `#retry_on` API with no wait and no jitter
+      # things like continuation and `#retry_on` API with no wait and no jitter.
       #
       # @param job [Object] job we cannot enqueue
       # @param timestamp [Time] time when job should run
       #
-      # @note Karafka Pro supports future jobs
+      # @note Karafka Pro supports future jobs via the Scheduled Messages feature
+      #
+      # @note For ActiveJob Continuation to work without Pro, configure your continuable jobs:
+      #   self.resume_options = { wait: 0 }
       #
-      # @note In order for jobs to work with this you need to set jitter to false and no wait
+      # @note For `#retry_on` to work without Pro, configure with:
+      #   retry_on SomeError, wait: 0, jitter: 0
       def dispatch_at(job, timestamp)
         # Dispatch at is used by some of the ActiveJob features that actually do not back-off
         # but things go via this API nonetheless.
@@ -64,13 +72,31 @@ module Karafka
         else
           raise NotImplementedError, <<~ERROR_MESSAGE
             This queueing backend does not support scheduling future jobs.
-            Consider using Karafka Pro, which supports this via the Scheduled Messages feature.
+
+            If you're using ActiveJob Continuation, configure your jobs with:
+              self.resume_options = { wait: 0 }
+
+            If you're using retry_on, configure with:
+              retry_on SomeError, wait: 0, jitter: 0
+
+            For full support of delayed job execution, consider using Karafka Pro with Scheduled Messages.
           ERROR_MESSAGE
         end
       end
 
       private
 
+      # Serializes a job using the configured deserializer
+      # This method serves as an extension point and can be wrapped by modules like
+      # CurrentAttributes::Persistence
+      #
+      # @param job [ActiveJob::Base, CurrentAttributes::Persistence::JobWrapper] job to serialize.
+      #   When CurrentAttributes are used, this may be a JobWrapper instead of the original job.
+      # @return [String] serialized job payload
+      def serialize_job(job)
+        deserializer.serialize(job)
+      end
+
       # @param job [ActiveJob::Base] job
       # @param key [Symbol] key we want to fetch
       # @param defaults [Hash]
@@ -81,12 +107,6 @@ module Karafka
           .karafka_options
           .fetch(key, defaults.fetch(key))
       end
-
-      # @param job [ActiveJob::Base] job
-      # @return [Hash] json representation of the job
-      def serialize_job(job)
-        job.serialize
-      end
     end
   end
 end

data/lib/karafka/active_job/job_options_contract.rb

@@ -8,10 +8,8 @@ module Karafka
     #   all in the same place
     class JobOptionsContract < Contracts::Base
       configure do |config|
-        config.error_messages = YAML.safe_load(
-          File.read(
-            File.join(Karafka.gem_root, 'config', 'locales', 'errors.yml')
-          )
+        config.error_messages = YAML.safe_load_file(
+          File.join(Karafka.gem_root, 'config', 'locales', 'errors.yml')
         ).fetch('en').fetch('validations').fetch('job_options')
       end
 

data/lib/karafka/admin/acl.rb

@@ -98,8 +98,10 @@ module Karafka
         PERMISSION_TYPES_MAP
       ].freeze
 
-      private_constant :RESOURCE_TYPES_MAP, :RESOURCE_PATTERNS_TYPE_MAP, :OPERATIONS_MAP,
-                       :PERMISSION_TYPES_MAP, :ALL_MAPS
+      private_constant(
+        :RESOURCE_TYPES_MAP, :RESOURCE_PATTERNS_TYPE_MAP, :OPERATIONS_MAP, :PERMISSION_TYPES_MAP,
+        :ALL_MAPS
+      )
 
       # Class level APIs that operate on Acl instances and/or return Acl instances.
       # @note For the sake of consistency all methods from this API return array of Acls
@@ -187,8 +189,10 @@ module Karafka
         end
       end
 
-      attr_reader :resource_type, :resource_name, :resource_pattern_type, :principal, :host,
-                  :operation, :permission_type
+      attr_reader(
+        :resource_type, :resource_name, :resource_pattern_type, :principal, :host, :operation,
+        :permission_type
+      )
 
       # Initializes a new Acl instance with specified attributes.
       #

data/lib/karafka/admin/configs/config.rb

@@ -71,10 +71,12 @@ module Karafka
         def synonym? = @synonym.positive?
 
         # @return [Hash] hash that we can use to operate with rdkafka
-        def to_native_hash = {
-          name: name,
-          value: value
-        }.freeze
+        def to_native_hash
+          {
+            name: name,
+            value: value
+          }.freeze
+        end
       end
     end
   end

data/lib/karafka/admin/configs/resource.rb

@@ -40,10 +40,16 @@ module Karafka
         OPERATIONS_TYPES_MAP.each do |op_name, op_value|
           # Adds an outgoing operation to a given resource of a given type
           # Useful since we alter in batches and not one at a time
+          #
+          # For example, when op_name is :set and op_value is 0:
+          #   def set(name, value)
+          #     @operations[0] << Config.new(name: name, value: value.to_s)
+          #   end
+          default_value = op_name == :delete ? ' = nil' : ''
           class_eval <<~RUBY, __FILE__, __LINE__ + 1
             # @param name [String] name of the config to alter
             # @param value [String] value of the config
-            def #{op_name}(name, value #{op_name == :delete ? ' = nil' : ''})
+            def #{op_name}(name, value#{default_value})
               @operations[#{op_value}] << Config.new(name: name, value: value.to_s)
             end
           RUBY

data/lib/karafka/admin/consumer_groups.rb

@@ -80,15 +80,13 @@ module Karafka
               case casted_position
               # Earliest is not always 0. When compacting/deleting it can be much later, that's why
               # we fetch the oldest possible offset
-              when 'earliest'
+              # false is treated the same as 'earliest'
+              when 'earliest', false
                 LONG_TIME_AGO
               # Latest will always be the high-watermark offset and we can get it just by getting
               # a future position
               when 'latest'
                 Time.now + DAY_IN_SECONDS
-              # Same as `'earliest'`
-              when false
-                LONG_TIME_AGO
               # Regular offset case
               else
                 position
@@ -234,17 +232,87 @@ module Karafka
           end
         end
 
+        # Triggers a rebalance for the specified consumer group by briefly joining and leaving
+        #
+        # @param consumer_group_id [String] consumer group id to trigger rebalance for
+        #
+        # @return [void]
+        #
+        # @raise [Karafka::Errors::InvalidConfigurationError] when consumer group is not found in
+        #   routing or has no topics
+        #
+        # @note This method creates a temporary "fake" consumer that joins the consumer group,
+        #   triggering a rebalance when it joins and another when it leaves. This should only be
+        #   used for operational/testing purposes as it causes two rebalances.
+        #
+        # @note The consumer group does not need to be running for this to work, but if it is,
+        #   it will experience rebalances.
+        #
+        # @note The behavior follows the configured rebalance protocol. For cooperative sticky
+        #   rebalancing or KIP-848 based protocols, there may be no immediate reaction to the
+        #   rebalance trigger as these protocols allow incremental partition reassignments without
+        #   stopping all consumers.
+        #
+        # @note Topics are always detected from the routing configuration. The consumer settings
+        #   (kafka config) are taken from the first topic in the consumer group to ensure
+        #   consistency with the actual consumer configuration.
+        #
+        # @example Trigger rebalance for a consumer group
+        #   Karafka::Admin::ConsumerGroups.trigger_rebalance('my-group')
+        def trigger_rebalance(consumer_group_id)
+          consumer_group = Karafka::App.routes.find { |cg| cg.id == consumer_group_id }
+
+          unless consumer_group
+            raise(
+              Errors::InvalidConfigurationError,
+              "Consumer group '#{consumer_group_id}' not found in routing"
+            )
+          end
+
+          topics = consumer_group.topics.map(&:name)
+
+          if topics.empty?
+            raise(
+              Errors::InvalidConfigurationError,
+              "Consumer group '#{consumer_group_id}' has no topics"
+            )
+          end
+
+          # Get the first topic to extract kafka settings
+          first_topic = consumer_group.topics.first
+
+          # Build consumer settings using the consumer group's kafka config from first topic
+          # This ensures we use the same settings as the actual consumers
+          # Following the same pattern as in Karafka::Connection::Client#build_kafka
+          consumer_settings = Setup::AttributesMap.consumer(first_topic.kafka.dup)
+          consumer_settings[:'group.id'] = consumer_group.id
+          consumer_settings[:'enable.auto.offset.store'] = false
+          consumer_settings[:'auto.offset.reset'] ||= first_topic.initial_offset
+
+          with_consumer(consumer_settings) do |consumer|
+            # Subscribe to the topics - this triggers the first rebalance
+            consumer.subscribe(*topics)
+
+            # Wait briefly (100ms) to allow the rebalance to initiate
+            # The actual rebalance happens asynchronously, so we just need to give it a moment
+            sleep(0.1)
+
+            # Unsubscribe - this will trigger the second rebalance when the consumer closes
+            # The ensure block in with_consumer will handle the unsubscribe and close
+          end
+        end
+
         # Reads lags and offsets for given topics in the context of consumer groups defined in the
         #   routing
         #
-        # @param consumer_groups_with_topics [Hash<String, Array<String>>] hash with consumer
+        # @param consumer_groups_with_topics [Hash{String => Array<String>}] hash with consumer
         #   groups names with array of topics to query per consumer group inside
         # @param active_topics_only [Boolean] if set to false, when we use routing topics, will
         #   select also topics that are marked as inactive in routing
         #
-        # @return [Hash<String, Hash<Integer, <Hash<Integer>>>>] hash where the top level keys are
-        #   the consumer groups and values are hashes with topics and inside partitions with lags
-        #   and offsets
+        # @return [Hash{String => Hash{Integer => Hash{Integer => Object}}}] hash where the top
+        #   level keys are the consumer groups and values are hashes with topics and inside
+        #   partitions with lags and offsets
         #
         # @note For topics that do not exist, topic details will be set to an empty hash
         #
@@ -257,19 +325,19 @@ module Karafka
           # We first fetch all the topics with partitions count that exist in the cluster so we
           # do not query for topics that do not exist and so we can get partitions count for all
           # the topics we may need. The non-existent and not consumed will be filled at the end
-          existing_topics = cluster_info.topics.map do |topic|
+          existing_topics = cluster_info.topics.to_h do |topic|
             [topic[:topic_name], topic[:partition_count]]
-          end.to_h.freeze
+          end.freeze
 
           # If no expected CGs, we use all from routing that have active topics
           if consumer_groups_with_topics.empty?
-            consumer_groups_with_topics = Karafka::App.routes.map do |cg|
+            consumer_groups_with_topics = Karafka::App.routes.to_h do |cg|
               cg_topics = cg.topics.select do |cg_topic|
                 active_topics_only ? cg_topic.active? : true
               end
 
               [cg.id, cg_topics.map(&:name)]
-            end.to_h
+            end
           end
 
           # We make a copy because we will remove once with non-existing topics

data/lib/karafka/admin/topics.rb

@@ -36,7 +36,7 @@ module Karafka
 
             # Build the requested range - since first element is on the start offset we need to
             # subtract one from requested count to end up with expected number of elements
-            requested_range = (start_offset..start_offset + (count - 1))
+            requested_range = (start_offset..(start_offset + count - 1))
             # Establish theoretical available range. Note, that this does not handle cases related
             # to log retention or compaction
             available_range = (low_offset..(high_offset - 1))
@@ -75,7 +75,7 @@ module Karafka
           # Use topic from routes if we can match it or create a dummy one
           # Dummy one is used in case we cannot match the topic with routes. This can happen
           # when admin API is used to read topics that are not part of the routing
-          topic = ::Karafka::Routing::Router.find_or_initialize_by_name(name)
+          topic = Karafka::Routing::Router.find_or_initialize_by_name(name)
 
           messages.map! do |message|
             Messages::Builders::Message.call(
@@ -139,15 +139,49 @@ module Karafka
           end
         end
 
-        # Fetches the watermark offsets for a given topic partition
+        # Fetches the watermark offsets for a given topic partition or multiple topics and
+        # partitions
         #
-        # @param name [String, Symbol] topic name
-        # @param partition [Integer] partition
-        # @return [Array<Integer, Integer>] low watermark offset and high watermark offset
-        def read_watermark_offsets(name, partition)
+        # @param name_or_hash [String, Symbol, Hash] topic name or hash with topics and partitions
+        # @param partition [Integer, nil] partition number
+        #   (required when first param is topic name)
+        #
+        # @return [Array<Integer, Integer>, Hash] when querying single partition returns array with
+        #   low and high watermark offsets, when querying multiple returns nested hash
+        #
+        # @example Query single partition
+        #   Karafka::Admin::Topics.read_watermark_offsets('events', 0)
+        #   # => [0, 100]
+        #
+        # @example Query specific partitions across multiple topics
+        #   Karafka::Admin::Topics.read_watermark_offsets(
+        #     { 'events' => [0, 1], 'logs' => [0] }
+        #   )
+        #   # => {
+        #   #   'events' => {
+        #   #     0 => [0, 100],
+        #   #     1 => [0, 150]
+        #   #   },
+        #   #   'logs' => {
+        #   #     0 => [0, 50]
+        #   #   }
+        #   # }
+        def read_watermark_offsets(name_or_hash, partition = nil)
+          # Normalize input to hash format
+          topics_with_partitions = partition ? { name_or_hash => [partition] } : name_or_hash
+
+          result = Hash.new { |h, k| h[k] = {} }
+
           with_consumer do |consumer|
-            consumer.query_watermark_offsets(name, partition)
+            topics_with_partitions.each do |topic, partitions|
+              partitions.each do |partition_id|
+                result[topic][partition_id] = consumer.query_watermark_offsets(topic, partition_id)
+              end
+            end
           end
+
+          # Return single array for single partition query, hash for multiple
+          partition ? result.dig(name_or_hash, partition) : result
         end
 
         # Returns basic topic metadata
@@ -184,7 +218,7 @@ module Karafka
         # @return [Integer] expected offset
         def resolve_offset(consumer, name, partition, offset)
           if offset.is_a?(Time)
-            tpl = ::Rdkafka::Consumer::TopicPartitionList.new
+            tpl = Rdkafka::Consumer::TopicPartitionList.new
             tpl.add_topic_and_partitions_with_offsets(
               name, partition => offset
             )

data/lib/karafka/admin.rb

@@ -59,11 +59,11 @@ module Karafka
         Topics.create_partitions(name, partitions)
       end
 
-      # @param name [String, Symbol] topic name
-      # @param partition [Integer] partition
+      # @param name_or_hash [String, Symbol, Hash] topic name or hash with topics and partitions
+      # @param partition [Integer, nil] partition (nil when using hash format)
       # @see Topics.read_watermark_offsets
-      def read_watermark_offsets(name, partition)
-        Topics.read_watermark_offsets(name, partition)
+      def read_watermark_offsets(name_or_hash, partition = nil)
+        Topics.read_watermark_offsets(name_or_hash, partition)
       end
 
       # @param topic_name [String] name of the topic we're interested in
@@ -113,15 +113,24 @@ module Karafka
         ConsumerGroups.delete(consumer_group_id)
       end
 
+      # Triggers a rebalance for the specified consumer group
+      #
+      # @param consumer_group_id [String] consumer group id to trigger rebalance for
+      # @see ConsumerGroups.trigger_rebalance
+      # @note This API should be used only for development.
+      def trigger_rebalance(consumer_group_id)
+        ConsumerGroups.trigger_rebalance(consumer_group_id)
+      end
+
       # Reads lags and offsets for given topics in the context of consumer groups defined in the
       #   routing
-      # @param consumer_groups_with_topics [Hash<String, Array<String>>] hash with consumer groups
-      #   names with array of topics to query per consumer group inside
+      # @param consumer_groups_with_topics [Hash{String => Array<String>}] hash with consumer
+      #   groups names with array of topics to query per consumer group inside
       # @param active_topics_only [Boolean] if set to false, when we use routing topics, will
       #   select also topics that are marked as inactive in routing
-      # @return [Hash<String, Hash<Integer, <Hash<Integer>>>>] hash where the top level keys are
-      #   the consumer groups and values are hashes with topics and inside partitions with lags
-      #   and offsets
+      # @return [Hash{String => Hash{Integer => Hash{Integer => Object}}}] hash where the top
+      #   level keys are the consumer groups and values are hashes with topics and inside
+      #   partitions with lags and offsets
       # @see ConsumerGroups.read_lags_with_offsets
       def read_lags_with_offsets(consumer_groups_with_topics = {}, active_topics_only: true)
         ConsumerGroups.read_lags_with_offsets(
@@ -149,7 +158,7 @@ module Karafka
         bind_oauth(bind_id, consumer)
 
         consumer.start
-        proxy = ::Karafka::Connection::Proxy.new(consumer)
+        proxy = Karafka::Connection::Proxy.new(consumer)
         yield(proxy)
       ensure
         # Always unsubscribe consumer just to be sure, that no metadata requests are running
@@ -179,7 +188,7 @@ module Karafka
         bind_oauth(bind_id, admin)
 
         admin.start
-        proxy = ::Karafka::Connection::Proxy.new(admin)
+        proxy = Karafka::Connection::Proxy.new(admin)
         yield(proxy)
       ensure
         admin&.close
@@ -202,7 +211,7 @@ module Karafka
       # @param instance [Rdkafka::Consumer, Rdkafka::Admin] rdkafka instance to be used to set
       #   appropriate oauth token when needed
       def bind_oauth(id, instance)
-        ::Karafka::Core::Instrumentation.oauthbearer_token_refresh_callbacks.add(
+        Karafka::Core::Instrumentation.oauthbearer_token_refresh_callbacks.add(
           id,
           Instrumentation::Callbacks::OauthbearerTokenRefresh.new(
             instance
@@ -215,7 +224,7 @@ module Karafka
       # @param id [String, Symbol] unique (for the lifetime of instance) id that we use for
       #   callback referencing
       def unbind_oauth(id)
-        ::Karafka::Core::Instrumentation.oauthbearer_token_refresh_callbacks.delete(id)
+        Karafka::Core::Instrumentation.oauthbearer_token_refresh_callbacks.delete(id)
       end
 
       # There are some cases where rdkafka admin operations finish successfully but without the
@@ -260,7 +269,7 @@ module Karafka
           # consumer group or do something similar
           .merge!(settings)
           .then { |config| Karafka::Setup::AttributesMap.public_send(type, config) }
-          .then { |config| ::Rdkafka::Config.new(config) }
+          .then { |config| Rdkafka::Config.new(config) }
       end
     end
   end

data/lib/karafka/app.rb

@@ -52,7 +52,7 @@ module Karafka
 
       # Returns current assignments of this process. Both topics and partitions
       #
-      # @return [Hash<Karafka::Routing::Topic, Array<Integer>>]
+      # @return [Hash{Karafka::Routing::Topic => Array<Integer>}]
       def assignments
         Instrumentation::AssignmentsTracker.instance.current
       end
@@ -102,8 +102,8 @@ module Karafka
       #
       # @param contexts [String] librdkafka low level debug contexts for granular debugging
       def debug!(contexts = 'all')
-        logger.level = ::Logger::DEBUG
-        producer.config.logger.level = ::Logger::DEBUG
+        logger.level = Logger::DEBUG
+        producer.config.logger.level = Logger::DEBUG
 
         config.kafka[:debug] = contexts
         producer.config.kafka[:debug] = contexts

data/lib/karafka/base_consumer.rb

@@ -5,7 +5,7 @@ module Karafka
   # Base consumer from which all Karafka consumers should inherit
   class BaseConsumer
     # Allow for consumer instance tagging for instrumentation
-    include ::Karafka::Core::Taggable
+    include Karafka::Core::Taggable
     include Helpers::ConfigImporter.new(
       monitor: %i[monitor]
     )
@@ -14,8 +14,9 @@ module Karafka
 
     def_delegators :@coordinator, :topic, :partition, :eofed?, :seek_offset, :seek_offset=
 
-    def_delegators :producer, :produce_async, :produce_sync, :produce_many_async,
-                   :produce_many_sync
+    def_delegators(
+      :producer, :produce_async, :produce_sync, :produce_many_async, :produce_many_sync
+    )
 
     def_delegators :messages, :each
 
@@ -81,9 +82,8 @@ module Karafka
     # @private
     #
     # @param action [Symbol]
-    # @param block [Proc]
-    def on_wrap(action, &block)
-      handle_wrap(action, &block)
+    def on_wrap(action, &)
+      handle_wrap(action, &)
     rescue StandardError => e
       monitor.instrument(
         'error.occurred',

data/lib/karafka/cli/base.rb

@@ -68,11 +68,11 @@ module Karafka
 
           # However when it is unavailable, we still want to be able to run help command
           # and install command as they don't require configured app itself to run
-          return if %w[-h install].any? { |cmd| cmd == ARGV[0] }
+          return if %w[-h install].any?(ARGV[0])
 
           # All other commands except help and install do require an existing boot file if it was
           # declared
-          raise ::Karafka::Errors::MissingBootFileError, ::Karafka.boot_file
+          raise Karafka::Errors::MissingBootFileError, Karafka.boot_file
         end
 
         # Allows to set options for Thor cli

data/lib/karafka/cli/console.rb

@@ -28,7 +28,7 @@ module Karafka
       def call
         Info.new.call
 
-        command = ::Karafka.rails? ? self.class.rails_console : self.class.console
+        command = Karafka.rails? ? self.class.rails_console : self.class.console
 
         exec "KARAFKA_CONSOLE=true #{command}"
       end

data/lib/karafka/cli/contracts/server.rb

@@ -5,12 +5,10 @@ module Karafka
     # CLI related contracts
     module Contracts
       # Contract for validating correctness of the server cli command options.
-      class Server < ::Karafka::Contracts::Base
+      class Server < Karafka::Contracts::Base
         configure do |config|
-          config.error_messages = YAML.safe_load(
-            File.read(
-              File.join(Karafka.gem_root, 'config', 'locales', 'errors.yml')
-            )
+          config.error_messages = YAML.safe_load_file(
+            File.join(Karafka.gem_root, 'config', 'locales', 'errors.yml')
           ).fetch('en').fetch('validations').fetch('cli').fetch('server')
         end