karafka 2.4.0 → 2.4.18

data/config/locales/errors.yml

@@ -14,6 +14,7 @@ en:
       pause_max_timeout_format: needs to be an integer bigger than 0
       pause_with_exponential_backoff_format: needs to be either true or false
       strict_topics_namespacing_format: needs to be either true or false
+      strict_declarative_topics_format: needs to be either true or false
       shutdown_timeout_format: needs to be an integer bigger than 0
       max_wait_time_format: needs to be an integer bigger than 0
       max_wait_time_max_wait_time_vs_swarm_node_report_timeout: >
@@ -33,6 +34,8 @@ en:
       internal.processing.partitioner_class_format: cannot be nil
       internal.processing.strategy_selector_format: cannot be nil
       internal.processing.expansions_selector_format: cannot be nil
+      internal.processing.executor_class_format: cannot be nil
+      internal.processing.worker_job_call_wrapper_format: 'needs to be false or respond to #wrap'
 
       internal.active_job.dispatcher_format: cannot be nil
       internal.active_job.job_options_contract_format: cannot be nil
@@ -49,6 +52,7 @@ en:
 
       internal.connection.manager_format: needs to be present
       internal.connection.conductor_format: needs to be present
+      internal.connection.reset_backoff_format: needs to be an integer bigger or equal to 1000
       internal.connection.proxy.query_watermark_offsets.timeout_format: needs to be an integer bigger than 0
       internal.connection.proxy.query_watermark_offsets.max_attempts_format: needs to be an integer bigger than 0
       internal.connection.proxy.query_watermark_offsets.wait_time_format: needs to be an integer bigger than 0
@@ -91,6 +95,7 @@ en:
 
     topic:
       kafka: needs to be a hash with kafka scope settings details
+      kafka_format: needs to be a filled hash
       missing: needs to be present
       max_messages_format: 'needs to be an integer bigger than 0'
       max_wait_time_format: 'needs to be an integer bigger than 0'
@@ -112,17 +117,22 @@ en:
       dead_letter_queue.transactional_format: needs to be either true or false
       dead_letter_queue.dispatch_method_format: 'needs to be either #produce_sync or #produce_async'
       dead_letter_queue.marking_method_format: 'needs to be either #mark_as_consumed or #mark_as_consumed!'
+      dead_letter_queue.mark_after_dispatch_format: 'needs to be true, false or nil'
 
       active_format: needs to be either true or false
 
+      eofed.active_format: needs to be either true or false
+      eofed.kafka_enable: 'cannot be enabled without enable.partition.eof set to true'
+
       declaratives.partitions_format: needs to be more or equal to 1
       declaratives.active_format: needs to be true
       declaratives.replication_factor_format: needs to be more or equal to 1
       declaratives.details_format: needs to be a hash with only symbol keys
 
       inconsistent_namespacing: |
-        needs to be consistent namespacing style
-        disable this validation by setting config.strict_topics_namespacing to false
+        needs to follow a consistent namespacing style using either dots (.) or underscores (_), but not both.
+        This ensures proper Kafka metrics reporting and avoids name collisions.
+        To disable this validation, set config.strict_topics_namespacing to false.
 
       deserializers.active_format: 'needs to be true'
       deserializers.payload_format: 'needs to respond to #call'
@@ -132,18 +142,24 @@ en:
     consumer_group:
       missing: needs to be present
       topics_names_not_unique: all topic names within a single consumer group must be unique
+      topics_many_consumers_same_topic: 'topic within a single consumer group cannot have distinct consumers'
       id_format: 'needs to be a string with a Kafka accepted format'
       topics_format: needs to be a non-empty array
       topics_namespaced_names_not_unique: |
         all topic names within a single consumer group must be unique considering namespacing styles
         disable this validation by setting config.strict_topics_namespacing to false
 
+    routing:
+      without_declarative_definition: lacks explicit declarative topics definition
+
     job_options:
       missing: needs to be present
       dispatch_method_format: needs to be either :produce_async or :produce_sync
       dispatch_many_method_format: needs to be either :produce_many_async or :produce_many_sync
       partitioner_format: 'needs to respond to #call'
       partition_key_type_format: 'needs to be either :key or :partition_key'
+      producer_format: 'needs to respond to #call'
+      scheduled_messages_topic_format: 'needs to be a string with a Kafka accepted format'
 
     test:
       missing: needs to be present

data/config/locales/pro_errors.yml

@@ -4,6 +4,7 @@ en:
       virtual_partitions.partitioner_respond_to_call: needs to be defined and needs to respond to `#call`
       virtual_partitions.max_partitions_format: needs to be equal or more than 1
       virtual_partitions.offset_metadata_strategy_format: needs to be either :exact or :current
+      virtual_partitions.reducer_format: "needs to respond to `#call`"
 
       long_running_job.active_format: needs to be either true or false
 
@@ -62,6 +63,10 @@ en:
       swarm.nodes_format: needs to be a range, array of nodes ids or a hash with direct assignments
       swarm_nodes_with_non_existent_nodes: includes unreachable nodes ids
 
+      recurring_tasks.active_format: 'needs to be boolean'
+      scheduled_messages.active_format: 'needs to be boolean'
+      scheduled_messages.active_missing: 'needs to be boolean'
+
       direct_assignments.active_missing: needs to be present
       direct_assignments.active_format: 'needs to be boolean'
       direct_assignments.partitions_missing: 'needs to be present'
@@ -71,6 +76,14 @@ en:
       direct_assignments_swarm_overbooked: 'cannot allocate partitions in swarm that were not assigned'
       direct_assignments_patterns_active: 'patterns cannot be used with direct assignments'
 
+      adaptive_iterator.active_missing: needs to be present
+      adaptive_iterator.active_format: 'needs to be boolean'
+      adaptive_iterator.marking_method_format: 'needs to be either #mark_as_consumed or #mark_as_consumed!'
+      adaptive_iterator.clean_after_yielding_format: 'needs to be boolean'
+      adaptive_iterator.safety_margin_format: 'needs to be between 1 and 99'
+      adaptive_iterator_with_virtual_partitions: 'cannot be used with virtual partitions'
+      adaptive_iterator_with_long_running_job: 'cannot be used with long running jobs'
+
     consumer_group:
       patterns_format: must be an array with hashes
       patterns_missing: needs to be present
@@ -98,5 +111,36 @@ en:
       patterns.ttl_format: needs to be an integer bigger than 0
       patterns.ttl_missing: needs to be present
 
+      recurring_tasks.consumer_class_format: 'needs to inherit from Karafka::BaseConsumer'
+      recurring_tasks.group_id_format: 'needs to be a string with a Kafka accepted format'
+      recurring_tasks.topics.schedules_format: 'needs to be a string with a Kafka accepted format'
+      recurring_tasks.topics.logs_format: 'needs to be a string with a Kafka accepted format'
+      recurring_tasks.interval_format: 'needs to be equal or more than 1000 and an integer'
+      recurring_tasks.deserializer_format: 'needs to be configured'
+      recurring_tasks.logging_format: needs to be a boolean
+
+      scheduled_messages.consumer_class_format: 'must be a class'
+      scheduled_messages.dispatcher_class_format: 'must be a class'
+      scheduled_messages.flush_batch_size_format: needs to be an integer bigger than 0
+      scheduled_messages.interval_format: needs to be an integer bigger or equal to 1000
+      scheduled_messages.deserializers.headers_format: cannot be nil
+      scheduled_messages.deserializers.payload_format: cannot be nil
+      scheduled_messages.group_id_format: 'needs to be a string with a Kafka accepted format'
+      scheduled_messages.states_postfix_format: 'needs to be a string with a Kafka accepted format'
+
     routing:
       swarm_nodes_not_used: 'At least one of the nodes has no assignments'
+
+    recurring_tasks:
+      id_format: 'can include only alphanumeric characters (a-z, A-Z, 0-9), hyphens (-), and underscores (_)'
+      cron_format: must be a non-empty string
+      enabled_format: needs to be a boolean
+      changed_format: needs to be a boolean
+      previous_time_format: needs to be a numerical or time
+
+    scheduled_messages_message:
+      key_missing: must be present and should be unique within the partition
+      key_format: needs to be a non-empty string unique within the partition
+      headers_schedule_target_epoch_in_the_past: 'scheduling cannot happen in the past'
+      headers_format: are not correct
+      not_a_scheduled_messages_topic: 'the envelope topic is not a scheduled messages topic'

data/docker-compose.yml

@@ -1,9 +1,7 @@
-version: '2'
-
 services:
   kafka:
     container_name: kafka
-    image: confluentinc/cp-kafka:7.6.1
+    image: confluentinc/cp-kafka:7.8.0
 
     ports:
       - 9092:9092

data/karafka.gemspec

@@ -12,7 +12,7 @@ Gem::Specification.new do |spec|
   spec.authors     = ['Maciej Mensfeld']
   spec.email       = %w[contact@karafka.io]
   spec.homepage    = 'https://karafka.io'
-  spec.licenses    = %w[LGPL-3.0 Commercial]
+  spec.licenses    = %w[LGPL-3.0-only Commercial]
   spec.summary     = 'Karafka is Ruby and Rails efficient Kafka processing framework.'
   spec.description = <<-DESC
     Karafka is Ruby and Rails efficient Kafka processing framework.
@@ -21,8 +21,10 @@ Gem::Specification.new do |spec|
     without having to focus on things that are not your business domain.
   DESC
 
-  spec.add_dependency 'karafka-core', '>= 2.4.0', '< 2.5.0'
-  spec.add_dependency 'waterdrop', '>= 2.7.0', '< 3.0.0'
+  spec.add_dependency 'base64', '~> 0.2'
+  spec.add_dependency 'karafka-core', '>= 2.4.4', '< 2.5.0'
+  spec.add_dependency 'karafka-rdkafka', '>= 0.17.2'
+  spec.add_dependency 'waterdrop', '>= 2.7.3', '< 3.0.0'
   spec.add_dependency 'zeitwerk', '~> 2.3'
 
   spec.required_ruby_version = '>= 3.0.0'
@@ -31,7 +33,7 @@ Gem::Specification.new do |spec|
     spec.signing_key = File.expand_path('~/.ssh/gem-private_key.pem')
   end
 
-  spec.cert_chain    = %w[certs/cert_chain.pem]
+  spec.cert_chain    = %w[certs/cert.pem]
   spec.files         = `git ls-files -z`.split("\x0").reject { |f| f.match(%r{^(spec)/}) }
   spec.executables   = %w[karafka]
   spec.require_paths = %w[lib]

data/lib/active_job/queue_adapters/karafka_adapter.rb

@@ -7,27 +7,38 @@ module ActiveJob
     # Karafka adapter for enqueuing jobs
     # This is here for ease of integration with ActiveJob.
     class KarafkaAdapter
+      include Karafka::Helpers::ConfigImporter.new(
+        dispatcher: %i[internal active_job dispatcher]
+      )
+
       # Enqueues the job using the configured dispatcher
       #
       # @param job [Object] job that should be enqueued
       def enqueue(job)
-        ::Karafka::App.config.internal.active_job.dispatcher.dispatch(job)
+        dispatcher.dispatch(job)
       end
 
       # Enqueues multiple jobs in one go
       # @param jobs [Array<Object>] jobs that we want to enqueue
       # @return [Integer] number of jobs enqueued (required by Rails)
       def enqueue_all(jobs)
-        ::Karafka::App.config.internal.active_job.dispatcher.dispatch_many(jobs)
+        dispatcher.dispatch_many(jobs)
         jobs.size
       end
 
-      # Raises info, that Karafka backend does not support scheduling jobs
+      # Delegates time sensitive dispatch to the dispatcher. OSS will raise error, Pro will handle
+      # this as it supports scheduled messages.
       #
-      # @param _job [Object] job we cannot enqueue
-      # @param _timestamp [Time] time when job should run
-      def enqueue_at(_job, _timestamp)
-        raise NotImplementedError, 'This queueing backend does not support scheduling jobs.'
+      # @param job [Object] job we want to enqueue
+      # @param timestamp [Time] time when job should run
+      def enqueue_at(job, timestamp)
+        dispatcher.dispatch_at(job, timestamp)
+      end
+
+      # @return [true] should we by default enqueue after the transaction and not during.
+      #   Defaults to true to prevent weird issues during rollbacks, etc.
+      def enqueue_after_transaction_commit?
+        true
       end
     end
   end

data/lib/karafka/active_job/dispatcher.rb

@@ -46,6 +46,19 @@ module Karafka
         end
       end
 
+      # Raises info, that Karafka backend does not support scheduling jobs
+      #
+      # @param _job [Object] job we cannot enqueue
+      # @param _timestamp [Time] time when job should run
+      #
+      # @note Karafka Pro supports this feature
+      def dispatch_at(_job, _timestamp)
+        raise NotImplementedError, <<~ERROR_MESSAGE
+          This queueing backend does not support scheduling jobs.
+          Consider using Karafka Pro, which supports this via the Scheduled Messages feature.
+        ERROR_MESSAGE
+      end
+
       private
 
       # @param job [ActiveJob::Base] job

data/lib/karafka/active_job/job_extensions.rb

@@ -23,6 +23,9 @@ module Karafka
         # them
         App.config.internal.active_job.job_options_contract.validate!(new_options)
 
+        # We need to modify this hash because otherwise we would modify parent hash.
+        self._karafka_options = _karafka_options.dup
+
         new_options.each do |name, value|
           _karafka_options[name] = value
         end

data/lib/karafka/admin.rb

@@ -10,6 +10,12 @@ module Karafka
   #   Cluster on which operations are performed can be changed via `admin.kafka` config, however
   #   there is no multi-cluster runtime support.
   module Admin
+    # More or less number of seconds of 1 hundred years
+    # Used for time referencing that does not have to be accurate but needs to be big
+    HUNDRED_YEARS = 100 * 365.25 * 24 * 60 * 60
+
+    private_constant :HUNDRED_YEARS
+
     class << self
       # Allows us to read messages from the topic
       #
@@ -156,6 +162,18 @@ module Karafka
       #
       # @example Move offset to 5 seconds ago on partition 2
       #   Karafka::Admin.seek_consumer_group('group-id', { 'topic' => { 2 => 5.seconds.ago } })
+      #
+      # @example Move to the earliest offset on all the partitions of a topic
+      #   Karafka::Admin.seek_consumer_group('group-id', { 'topic' => 'earliest' })
+      #
+      # @example Move to the latest (high-watermark) offset on all the partitions of a topic
+      #   Karafka::Admin.seek_consumer_group('group-id', { 'topic' => 'latest' })
+      #
+      # @example Move offset of a single partition to earliest
+      #   Karafka::Admin.seek_consumer_group('group-id', { 'topic' => { 1 => 'earliest' } })
+      #
+      # @example Move offset of a single partition to latest
+      #   Karafka::Admin.seek_consumer_group('group-id', { 'topic' => { 1 => 'latest' } })
       def seek_consumer_group(consumer_group_id, topics_with_partitions_and_offsets)
         tpl_base = {}
 
@@ -174,6 +192,32 @@ module Karafka
           end
         end
 
+        tpl_base.each_value do |partitions|
+          partitions.transform_values! do |position|
+            # Support both symbol and string based references
+            casted_position = position.is_a?(Symbol) ? position.to_s : position
+
+            # This remap allows us to transform some special cases in a reference that can be
+            # understood by Kafka
+            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'
+              Time.now - HUNDRED_YEARS
+            # Latest will always be the high-watermark offset and we can get it just by getting
+            # a future position
+            when 'latest'
+              Time.now + HUNDRED_YEARS
+            # Same as `'latest'`
+            when false
+              Time.now - HUNDRED_YEARS
+            # Regular offset case
+            else
+              position
+            end
+          end
+        end
+
         tpl = Rdkafka::Consumer::TopicPartitionList.new
         # In case of time based location, we need to to a pre-resolution, that's why we keep it
         # separately
@@ -230,6 +274,48 @@ module Karafka
         end
       end
 
+      # Takes consumer group and its topics and migrates all the offsets to a new named group
+      #
+      # @param previous_name [String] old consumer group name
+      # @param new_name [String] new consumer group name
+      # @param topics [Array<String>] topics for which we want to migrate offsets during rename
+      # @param delete_previous [Boolean] should we delete previous consumer group after rename.
+      #   Defaults to true.
+      #
+      # @note This method should **not** be executed on a running consumer group as it creates a
+      #   "fake" consumer and uses it to move offsets.
+      #
+      # @note After migration unless `delete_previous` is set to `false`, old group will be
+      #   removed.
+      #
+      # @note If new consumer group exists, old offsets will be added to it.
+      def rename_consumer_group(previous_name, new_name, topics, delete_previous: true)
+        remap = Hash.new { |h, k| h[k] = {} }
+
+        old_lags = read_lags_with_offsets({ previous_name => topics })
+
+        return if old_lags.empty?
+
+        read_lags_with_offsets({ previous_name => topics })
+          .fetch(previous_name)
+          .each do |topic, partitions|
+            partitions.each do |partition_id, details|
+              offset = details[:offset]
+
+              # No offset on this partition
+              next if offset.negative?
+
+              remap[topic][partition_id] = offset
+            end
+          end
+
+        seek_consumer_group(new_name, remap)
+
+        return unless delete_previous
+
+        delete_consumer_group(previous_name)
+      end
+
       # Removes given consumer group (if exists)
       #
       # @param consumer_group_id [String] consumer group name

data/lib/karafka/app.rb

@@ -95,6 +95,23 @@ module Karafka
           end
         RUBY
       end
+
+      # Forces the debug setup onto Karafka and default WaterDrop producer.
+      # This needs to run prior to any operations that would cache state, like consuming or
+      # producing messages.
+      #
+      # @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
+
+        config.kafka[:debug] = contexts
+        producer.config.kafka[:debug] = contexts
+
+        consumer_groups.map(&:topics).flat_map(&:to_a).each do |topic|
+          topic.kafka[:debug] = contexts
+        end
+      end
     end
   end
 end

data/lib/karafka/base_consumer.rb

@@ -6,14 +6,19 @@ module Karafka
   class BaseConsumer
     # Allow for consumer instance tagging for instrumentation
     include ::Karafka::Core::Taggable
+    include Helpers::ConfigImporter.new(
+      monitor: %i[monitor]
+    )
 
     extend Forwardable
 
-    def_delegators :@coordinator, :topic, :partition
+    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 :messages, :each
+
     # @return [String] id of the current consumer
     attr_reader :id
     # @return [Karafka::Routing::Topic] topic to which a given consumer is subscribed
@@ -31,6 +36,20 @@ module Karafka
       @used = false
     end
 
+    # Trigger method running after consumer is fully initialized.
+    #
+    # @private
+    def on_initialized
+      handle_initialized
+    rescue StandardError => e
+      monitor.instrument(
+        'error.occurred',
+        error: e,
+        caller: self,
+        type: 'consumer.initialized.error'
+      )
+    end
+
     # Can be used to run preparation code prior to the job being enqueued
     #
     # @private
@@ -57,6 +76,23 @@ module Karafka
       handle_before_consume
     end
 
+    # Executes the default wrapping flow
+    #
+    # @private
+    #
+    # @param action [Symbol]
+    # @param block [Proc]
+    def on_wrap(action, &block)
+      handle_wrap(action, &block)
+    rescue StandardError => e
+      monitor.instrument(
+        'error.occurred',
+        error: e,
+        caller: self,
+        type: 'consumer.wrap.error'
+      )
+    end
+
     # Executes the default consumer flow.
     #
     # @private
@@ -69,11 +105,11 @@ module Karafka
     def on_consume
       handle_consume
     rescue StandardError => e
-      Karafka.monitor.instrument(
+      monitor.instrument(
         'error.occurred',
         error: e,
         caller: self,
-        seek_offset: coordinator.seek_offset,
+        seek_offset: seek_offset,
         type: 'consumer.consume.error'
       )
     end
@@ -89,17 +125,35 @@ module Karafka
     def on_after_consume
       handle_after_consume
     rescue StandardError => e
-      Karafka.monitor.instrument(
+      monitor.instrument(
         'error.occurred',
         error: e,
         caller: self,
-        seek_offset: coordinator.seek_offset,
+        seek_offset: seek_offset,
         type: 'consumer.after_consume.error'
       )
 
       retry_after_pause
     end
 
+    # Can be used to run code prior to scheduling of eofed execution
+    def on_before_schedule_eofed
+      handle_before_schedule_eofed
+    end
+
+    # Trigger method for running on eof without messages
+    def on_eofed
+      handle_eofed
+    rescue StandardError => e
+      monitor.instrument(
+        'error.occurred',
+        error: e,
+        caller: self,
+        seek_offset: seek_offset,
+        type: 'consumer.eofed.error'
+      )
+    end
+
     # Can be used to run code prior to scheduling of idle execution
     #
     # @private
@@ -127,7 +181,7 @@ module Karafka
     def on_revoked
       handle_revoked
     rescue StandardError => e
-      Karafka.monitor.instrument(
+      monitor.instrument(
         'error.occurred',
         error: e,
         caller: self,
@@ -148,7 +202,7 @@ module Karafka
     def on_shutdown
       handle_shutdown
     rescue StandardError => e
-      Karafka.monitor.instrument(
+      monitor.instrument(
         'error.occurred',
         error: e,
         caller: self,
@@ -158,6 +212,15 @@ module Karafka
 
     private
 
+    # Method called post-initialization of a consumer when all basic things are assigned.
+    # Since initialization via `#initialize` is complex and some states are set a bit later, this
+    # hook allows to initialize resources once at a time when topic, partition and other things
+    # are assigned to the consumer
+    #
+    # @note Please keep in mind that it will run many times when persistence is off. Basically once
+    #   each batch.
+    def initialized; end
+
     # Method that will perform business logic and on data received from Kafka (it will consume
     #   the data)
     # @note This method needs to be implemented in a subclass. We stub it here as a failover if
@@ -166,6 +229,44 @@ module Karafka
       raise NotImplementedError, 'Implement this in a subclass'
     end
 
+    # This method can be redefined to build a wrapping API around user code + karafka flow control
+    # code starting from the user code (operations prior to that are not part of this).
+    # The wrapping relates to a single job flow.
+    #
+    # Karafka framework may require user configured "state" like for example a selected
+    # transactional producer that should be used not only by the user but also by the framework.
+    # By using this API user can checkout a producer and return it to the pool.
+    #
+    # @param _action [Symbol] what action are we wrapping. Useful if we want for example to only
+    #   wrap the `:consume` action.
+    # @yield Runs the execution block
+    #
+    # @note User related errors should not leak to this level of execution. This should not be used
+    #   for anything consumption related but only for setting up state that that Karafka code
+    #   may need outside of user code.
+    #
+    # @example Redefine to use a producer from a pool for consume
+    #   def wrap(action)
+    #     # Do not checkout producer for any other actions
+    #     return yield unless action == :consume
+    #
+    #     default_producer = self.producer
+    #
+    #     $producers.with do |producer|
+    #       self.producer = producer
+    #       yield
+    #     end
+    #
+    #     self.producer = default_producer
+    #   end
+    def wrap(_action)
+      yield
+    end
+
+    # Method that will be executed when a given topic partition reaches eof without any new
+    # incoming messages alongside
+    def eofed; end
+
     # Method that will be executed when a given topic partition is revoked. You can use it for
     # some teardown procedures (closing file handler, etc).
     def revoked; end
@@ -208,7 +309,7 @@ module Karafka
       # Indicate, that user took a manual action of pausing
       coordinator.manual_pause if manual_pause
 
-      Karafka.monitor.instrument(
+      monitor.instrument(
         'consumer.consuming.pause',
         caller: self,
         manual: manual_pause,
@@ -244,15 +345,25 @@ module Karafka
     # @note Please note, that if you are seeking to a time offset, getting the offset is blocking
     def seek(offset, manual_seek = true, reset_offset: false)
       coordinator.manual_seek if manual_seek
-      coordinator.seek_offset = nil if reset_offset
-
-      client.seek(
-        Karafka::Messages::Seek.new(
-          topic.name,
-          partition,
-          offset
-        )
+      self.seek_offset = nil if reset_offset
+
+      message = Karafka::Messages::Seek.new(
+        topic.name,
+        partition,
+        offset
       )
+
+      monitor.instrument(
+        'consumer.consuming.seek',
+        caller: self,
+        topic: topic.name,
+        partition: partition,
+        message: message,
+        manual_seek: manual_seek,
+        reset_offset: reset_offset
+      ) do
+        client.seek(message)
+      end
     end
 
     # @return [Boolean] true if partition was revoked from the current consumer
@@ -286,16 +397,16 @@ module Karafka
     # Pauses the processing from the last offset to retry on given message
     # @private
     def retry_after_pause
-      pause(coordinator.seek_offset, nil, false)
+      pause(seek_offset, nil, false)
 
       # Instrumentation needs to run **after** `#pause` invocation because we rely on the states
       # set by `#pause`
-      Karafka.monitor.instrument(
+      monitor.instrument(
         'consumer.consuming.retry',
         caller: self,
         topic: topic.name,
         partition: partition,
-        offset: coordinator.seek_offset,
+        offset: seek_offset,
         timeout: coordinator.pause_tracker.current_timeout,
         attempt: attempt
       )