karafka 2.0.0.beta5 → 2.0.0.rc1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 2c8e680ffdf69f88899a715c84cc484e8f568f4a93da9284195f4bf55a283ee1
-  data.tar.gz: 974356226a10ba2c77de770351a47180716533021a89040bcdc1aae57f452121
+  metadata.gz: 506ffb9aef3309eae2ee26e3283b7bc83859b26f4fe41995dca9d8f5e7bf0533
+  data.tar.gz: 14b39f0597676207bf9f2bf10b06c51ba539c3aa01959dfb2378c2e23941d240
 SHA512:
-  metadata.gz: 2427aaae1b1b07430df7c9f042d290bbae8380fb1f6ec7c26eecee92b8fe79e13ea9f3a99a36bf89b314ffba809c556618b22c0a87f0c0c83bb73cf8af72321b
-  data.tar.gz: 55e18448b5645acd38c4194967ea7df657c142d82a105699f7b204f222f8dfb2dbd14cce82b1f424ec177afb78049b3e7588642013674a3c2923a8848b6b87e7
+  metadata.gz: 4b2ad5ef4eff629abfc0088be0c400bd0f9420d24c05c1414541a4c167e7e6bf2b9735bf0e596358d8e3f3c2392bf2c2b4ba345cdb8f0226b54877ce111fd749
+  data.tar.gz: 93adbc64906ff4a03e67dee646a5fe696d825357753bb804c690036800c947edaa186b67e5da8db115a0cc4a9efa46e6b1e061a608e496255bbfdc6ddeb60c14

data/CHANGELOG.md

@@ -1,5 +1,13 @@
 # Karafka framework changelog
 
+## 2.0.0-rc1 (2022-07-08)
+- Extract consumption partitioner out of listener inline code.
+- Introduce virtual partitioner concept for parallel processing of data from a single topic partition.
+- Improve stability when there kafka internal errors occur while polling.
+- Fix a case where we would resume a LRJ partition upon rebalance where we would reclaim the partition while job was still running.
+- Do not revoke pauses for lost partitions. This will allow to un-pause reclaimed partitions when LRJ jobs are done.
+- Fail integrations by default (unless configured otherwise) if any errors occur during Karafka server execution.
+
 ## 2.0.0-beta5 (2022-07-05)
 - Always resume processing of a revoked partition upon assignment.
 - Improve specs stability.

data/CONTRIBUTING.md

@@ -34,8 +34,3 @@ By sending a pull request to the pro components, you are agreeing to transfer th
 
 If you have any questions, create an [issue](issue) (protip: do a quick search first to see if someone else didn't ask the same question before!).
 You can also reach us at hello@karafka.opencollective.com.
-
-## Credits
-
-Thank you to all the people who have already contributed to karafka!
-<a href="graphs/contributors"><img src="https://opencollective.com/karafka/contributors.svg?width=890" /></a>

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    karafka (2.0.0.beta5)
+    karafka (2.0.0.rc1)
       dry-configurable (~> 0.13)
       dry-monitor (~> 0.5)
       dry-validation (~> 1.7)
@@ -45,7 +45,7 @@ GEM
       dry-configurable (~> 0.13, >= 0.13.0)
       dry-core (~> 0.5, >= 0.5)
       dry-events (~> 0.2)
-    dry-schema (1.9.2)
+    dry-schema (1.9.3)
       concurrent-ruby (~> 1.0)
       dry-configurable (~> 0.13, >= 0.13.0)
       dry-core (~> 0.5, >= 0.5)

data/README.md

@@ -8,7 +8,7 @@
 
 ## About Karafka
 
-Karafka is a framework used to simplify Apache Kafka based Ruby and Ruby on Rails applications development.
+Karafka is a multi-threaded framework used to simplify Apache Kafka based Ruby and Ruby on Rails applications development.
 
 ```ruby
 # Define what topics you want to consume with which consumers in karafka.rb
@@ -45,7 +45,7 @@ We also maintain many [integration specs](https://github.com/karafka/karafka/tre
 
 ## Want to Upgrade? LGPL is not for you? Want to help?
 
-I also sell Karafka Pro subscription. It includes commercial-friendly license, priority support, architecture consultations and high throughput data processing-related features (under development).
+I also sell Karafka Pro subscription. It includes commercial-friendly license, priority support, architecture consultations and high throughput data processing-related features (virtual partitions, long running jobs and more).
 
 **20%** of the income will be distributed back to other OSS projects that Karafka uses under the hood.
 
@@ -56,11 +56,3 @@ Help me provide high-quality open-source software. Please see the Karafka [homep
 Karafka has [Wiki pages](https://github.com/karafka/karafka/wiki) for almost everything and a pretty decent [FAQ](https://github.com/karafka/karafka/wiki/FAQ). It covers the whole installation, setup and deployment along with other useful details on how to run Karafka.
 
 If you have any questions about using Karafka, feel free to join our [Slack](https://slack.karafka.io) channel.
-
-## Note on contributions
-
-First, thank you for considering contributing to the Karafka ecosystem! It's people like you that make the open source community such a great community!
-
-Each pull request must pass all the RSpec specs, integration tests and meet our quality requirements.
-
-Fork it, update and wait for the Github Actions results.

data/bin/stress_many

@@ -8,6 +8,6 @@ set -e
 
 while :
 do
-  reset
+  clear
   bin/integrations $1
 done

data/bin/stress_one

@@ -8,6 +8,6 @@ set -e
 
 while :
 do
-  reset
+  clear
   bin/scenario $1
 done

data/docker-compose.yml

@@ -33,6 +33,9 @@ services:
          integrations_14_02:2:1,\
          integrations_15_02:2:1,\
          integrations_16_02:2:1,\
+         integrations_17_02:2:1,\
+         integrations_18_02:2:1,\
+         integrations_19_02:2:1,\
          integrations_00_03:3:1,\
          integrations_01_03:3:1,\
          integrations_02_03:3:1,\
@@ -41,6 +44,7 @@ services:
          integrations_01_10:10:1,\
          benchmarks_00_01:1:1,\
          benchmarks_00_05:5:1,\
+         benchmarks_01_05:5:1,\
          benchmarks_00_10:10:1"
     volumes:
       - /var/run/docker.sock:/var/run/docker.sock

data/lib/karafka/base_consumer.rb

@@ -35,9 +35,9 @@ module Karafka
         consume
       end
 
-      @coordinator.consumption(self).success!
+      coordinator.consumption(self).success!
     rescue StandardError => e
-      @coordinator.consumption(self).failure!
+      coordinator.consumption(self).failure!
 
       Karafka.monitor.instrument(
         'error.occurred',
@@ -47,7 +47,7 @@ module Karafka
       )
     ensure
       # We need to decrease number of jobs that this coordinator coordinates as it has finished
-      @coordinator.decrement
+      coordinator.decrement
     end
 
     # @private
@@ -56,7 +56,7 @@ module Karafka
     def on_after_consume
       return if revoked?
 
-      if @coordinator.success?
+      if coordinator.success?
         coordinator.pause_tracker.reset
 
         # Mark as consumed only if manual offset management is not on
@@ -76,8 +76,6 @@ module Karafka
     def on_revoked
       coordinator.revoke
 
-      resume
-
       Karafka.monitor.instrument('consumer.revoked', caller: self) do
         revoked
       end

data/lib/karafka/connection/client.rb

@@ -316,37 +316,40 @@ module Karafka
 
         time_poll.start
 
-        @kafka.poll(time_poll.remaining)
+        @kafka.poll(timeout)
       rescue ::Rdkafka::RdkafkaError => e
-        raise if time_poll.attempts > MAX_POLL_RETRIES
-        raise unless time_poll.retryable?
-
+        # We return nil, so we do not restart until running the whole loop
+        # This allows us to run revocation jobs and other things and we will pick up new work
+        # next time after dispatching all the things that are needed
+        #
+        # If we would retry here, the client reset would become transparent and we would not have
+        # a chance to take any actions
         case e.code
         when :max_poll_exceeded # -147
           reset
+          return nil
         when :transport # -195
           reset
+          return nil
         when :rebalance_in_progress # -27
           reset
+          return nil
         when :not_coordinator # 16
           reset
+          return nil
         when :network_exception # 13
           reset
+          return nil
         end
 
-        time_poll.checkpoint
-
+        raise if time_poll.attempts > MAX_POLL_RETRIES
         raise unless time_poll.retryable?
 
+        time_poll.checkpoint
         time_poll.backoff
 
-        # We return nil, so we do not restart until running the whole loop
-        # This allows us to run revocation jobs and other things and we will pick up new work
-        # next time after dispatching all the things that are needed
-        #
-        # If we would retry here, the client reset would become transparent and we would not have
-        # a chance to take any actions
-        nil
+        # On unknown errors we do our best to retry and handle them before raising
+        retry
       end
 
       # Builds a new rdkafka consumer instance based on the subscription group configuration

data/lib/karafka/connection/listener.rb

@@ -18,15 +18,18 @@ module Karafka
       # @param jobs_queue [Karafka::Processing::JobsQueue] queue where we should push work
       # @return [Karafka::Connection::Listener] listener instance
       def initialize(subscription_group, jobs_queue)
+        proc_config = ::Karafka::App.config.internal.processing
+
         @id = SecureRandom.uuid
         @subscription_group = subscription_group
         @jobs_queue = jobs_queue
-        @jobs_builder = ::Karafka::App.config.internal.processing.jobs_builder
         @coordinators = Processing::CoordinatorsBuffer.new
         @client = Client.new(@subscription_group)
         @executors = Processing::ExecutorsBuffer.new(@client, subscription_group)
+        @jobs_builder = proc_config.jobs_builder
+        @partitioner = proc_config.partitioner_class.new(subscription_group)
         # We reference scheduler here as it is much faster than fetching this each time
-        @scheduler = ::Karafka::App.config.internal.processing.scheduler
+        @scheduler = proc_config.scheduler
         # We keep one buffer for messages to preserve memory and not allocate extra objects
         # We can do this that way because we always first schedule jobs using messages before we
         # fetch another batch.
@@ -79,10 +82,6 @@ module Karafka
             poll_and_remap_messages
           end
 
-          # This will ensure, that in the next poll, we continue processing (if we get them back)
-          # partitions that we have paused
-          resume_assigned_partitions
-
           # If there were revoked partitions, we need to wait on their jobs to finish before
           # distributing consuming jobs as upon revoking, we might get assigned to the same
           # partitions, thus getting their jobs. The revoking jobs need to finish before
@@ -159,8 +158,6 @@ module Karafka
 
         revoked_partitions.each do |topic, partitions|
           partitions.each do |partition|
-            # We revoke the coordinator here, so we do not have to revoke it in the revoke job
-            # itself (this happens prior to scheduling those jobs)
             @coordinators.revoke(topic, partition)
 
             # There may be a case where we have lost partition of which data we have never
@@ -204,17 +201,6 @@ module Karafka
         )
       end
 
-      # Revoked partition needs to be resumed if we were processing them earlier. This will do
-      # nothing to things that we are planning to process. Without this, things we get
-      # re-assigned would not be polled.
-      def resume_assigned_partitions
-        @client.rebalance_manager.assigned_partitions.each do |topic, partitions|
-          partitions.each do |partition|
-            @client.resume(topic, partition)
-          end
-        end
-      end
-
       # Takes the messages per topic partition and enqueues processing jobs in threads using
       # given scheduler.
       def build_and_schedule_consumption_jobs
@@ -226,14 +212,16 @@ module Karafka
           coordinator = @coordinators.find_or_create(topic, partition)
 
           # Start work coordination for this topic partition
-          coordinator.start
+          coordinator.start(messages)
 
-          # Count the job we're going to create here
-          coordinator.increment
+          @partitioner.call(topic, messages) do |group_id, partition_messages|
+            # Count the job we're going to create here
+            coordinator.increment
 
-          executor = @executors.find_or_create(topic, partition, 0)
+            executor = @executors.find_or_create(topic, partition, group_id)
 
-          jobs << @jobs_builder.consume(executor, messages, coordinator)
+            jobs << @jobs_builder.consume(executor, partition_messages, coordinator)
+          end
         end
 
         @scheduler.schedule_consumption(@jobs_queue, jobs)

data/lib/karafka/connection/pauses_manager.rb

@@ -25,14 +25,6 @@ module Karafka
         )
       end
 
-      # Revokes pause tracker for a given topic partition
-      #
-      # @param topic [String] topic name
-      # @param partition [Integer] partition number
-      def revoke(topic, partition)
-        @pauses[topic].delete(partition)
-      end
-
       # Resumes processing of partitions for which pause time has ended.
       #
       # @yieldparam [String] topic name

data/lib/karafka/contracts/config.rb

@@ -42,6 +42,7 @@ module Karafka
             required(:jobs_builder)
             required(:scheduler)
             required(:coordinator_class)
+            required(:partitioner_class)
           end
 
           required(:active_job).schema do

data/lib/karafka/pro/base_consumer.rb

@@ -26,29 +26,38 @@ module Karafka
       # Pauses processing of a given partition until we're done with the processing
       # This ensures, that we can easily poll not reaching the `max.poll.interval`
       def on_before_consume
-        # Pause at the first message in a batch. That way in case of a crash, we will not loose
-        # any messages
         return unless topic.long_running_job?
 
-        pause(messages.first.offset, MAX_PAUSE_TIME)
+        # This ensures, that when running LRJ with VP, things operate as expected
+        coordinator.on_started do |first_group_message|
+          # Pause at the first message in a batch. That way in case of a crash, we will not loose
+          # any messages
+          pause(first_group_message.offset, MAX_PAUSE_TIME)
+        end
       end
 
       # Runs extra logic after consumption that is related to handling long running jobs
       # @note This overwrites the '#on_after_consume' from the base consumer
       def on_after_consume
-        # Nothing to do if we lost the partition
-        return if revoked?
+        coordinator.on_finished do |first_group_message, last_group_message|
+          on_after_consume_regular(first_group_message, last_group_message)
+        end
+      end
 
-        if @coordinator.success?
+      private
+
+      # Handles the post-consumption flow depending on topic settings
+      #
+      # @param first_message [Karafka::Messages::Message]
+      # @param last_message [Karafka::Messages::Message]
+      def on_after_consume_regular(first_message, last_message)
+        if coordinator.success?
           coordinator.pause_tracker.reset
 
           # We use the non-blocking one here. If someone needs the blocking one, can implement it
           # with manual offset management
           # Mark as consumed only if manual offset management is not on
-          mark_as_consumed(messages.last) unless topic.manual_offset_management?
-
-          # We check it twice as marking could change this state
-          return if revoked?
+          mark_as_consumed(last_message) unless topic.manual_offset_management? || revoked?
 
           # If this is not a long running job there is nothing for us to do here
           return unless topic.long_running_job?
@@ -60,12 +69,12 @@ module Karafka
           # interesting (yet valid) corner case, where with manual offset management on and no
           # marking as consumed, we end up with an infinite loop processing same messages over and
           # over again
-          seek(@seek_offset || messages.first.offset)
+          seek(@seek_offset || first_message.offset)
 
           resume
         else
           # If processing failed, we need to pause
-          pause(@seek_offset || messages.first.offset)
+          pause(@seek_offset || first_message.offset)
         end
       end
     end

data/lib/karafka/pro/loader.rb

@@ -21,6 +21,7 @@ module Karafka
         processing/jobs/consume_non_blocking
         processing/jobs_builder
         processing/coordinator
+        processing/partitioner
         routing/extensions
         active_job/consumer
         active_job/dispatcher
@@ -39,6 +40,7 @@ module Karafka
           icfg = config.internal
 
           icfg.processing.coordinator_class = Processing::Coordinator
+          icfg.processing.partitioner_class = Processing::Partitioner
           icfg.processing.scheduler = Processing::Scheduler.new
           icfg.processing.jobs_builder = Processing::JobsBuilder.new
 

data/lib/karafka/pro/processing/coordinator.rb

@@ -6,6 +6,57 @@ module Karafka
       # Pro coordinator that provides extra orchestration methods useful for parallel processing
       # within the same partition
       class Coordinator < ::Karafka::Processing::Coordinator
+        # @param args [Object] anything the base coordinator accepts
+        def initialize(*args)
+          super
+          @on_started_invoked = false
+          @on_finished_invoked = false
+          @flow_lock = Mutex.new
+        end
+
+        # Starts the coordination process
+        # @param messages [Array<Karafka::Messages::Message>] messages for which processing we are
+        #   going to coordinate.
+        def start(messages)
+          super
+
+          @mutex.synchronize do
+            @on_started_invoked = false
+            @on_finished_invoked = false
+            @first_message = messages.first
+            @last_message = messages.last
+          end
+        end
+
+        # @return [Boolean] is the coordinated work finished or not
+        def finished?
+          @running_jobs.zero?
+        end
+
+        # Runs given code only once per all the coordinated jobs upon starting first of them
+        def on_started
+          @flow_lock.synchronize do
+            return if @on_started_invoked
+
+            @on_started_invoked = true
+
+            yield(@first_message, @last_message)
+          end
+        end
+
+        # Runs once when all the work that is suppose to be coordinated is finished
+        # It runs once per all the coordinated jobs and should be used to run any type of post
+        # jobs coordination processing execution
+        def on_finished
+          @flow_lock.synchronize do
+            return unless finished?
+            return if @on_finished_invoked
+
+            @on_finished_invoked = true
+
+            yield(@first_message, @last_message)
+          end
+        end
       end
     end
   end

data/lib/karafka/pro/processing/partitioner.rb

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+# This Karafka component is a Pro component.
+# All of the commercial components are present in the lib/karafka/pro directory of this
+# repository and their usage requires commercial license agreement.
+#
+# Karafka has also commercial-friendly license, commercial support and commercial components.
+#
+# By sending a pull request to the pro components, you are agreeing to transfer the copyright of
+# your code to Maciej Mensfeld.
+
+module Karafka
+  module Pro
+    module Processing
+      # Pro partitioner that can distribute work based on the virtual partitioner settings
+      class Partitioner < ::Karafka::Processing::Partitioner
+        # @param topic [String] topic name
+        # @param messages [Array<Karafka::Messages::Message>] karafka messages
+        # @yieldparam [Integer] group id
+        # @yieldparam [Array<Karafka::Messages::Message>] karafka messages
+        def call(topic, messages)
+          ktopic = @subscription_group.topics.find(topic)
+
+          @concurrency ||= ::Karafka::App.config.concurrency
+
+          # We only partition work if we have a virtual partitioner and more than one thread to
+          # process the data. With one thread it is not worth partitioning the work as the work
+          # itself will be assigned to one thread (pointless work)
+          if ktopic.virtual_partitioner? && @concurrency > 1
+            messages
+              .group_by { |msg| ktopic.virtual_partitioner.call(msg).hash.abs % @concurrency }
+              .each { |group_id, messages_group| yield(group_id, messages_group) }
+          else
+            # When no virtual partitioner, works as regular one
+            yield(0, messages)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/karafka/pro/routing/extensions.rb

@@ -19,9 +19,15 @@ module Karafka
           # @param base [Class] class we extend
           def included(base)
             base.attr_accessor :long_running_job
+            base.attr_accessor :virtual_partitioner
           end
         end
 
+        # @return [Boolean] true if virtual partitioner is defined, false otherwise
+        def virtual_partitioner?
+          virtual_partitioner != nil
+        end
+
         # @return [Boolean] is a given job on a topic a long running one
         def long_running_job?
           @long_running_job || false

data/lib/karafka/processing/coordinator.rb

@@ -23,7 +23,9 @@ module Karafka
       end
 
       # Starts the coordinator for given consumption jobs
-      def start
+      # @param _messages [Array<Karafka::Messages::Message>] batch of message for which we are
+      #   going to coordinate work. Not used with regular coordinator.
+      def start(_messages)
         @mutex.synchronize do
           @running_jobs = 0
           # We need to clear the consumption results hash here, otherwise we could end up storing
@@ -44,7 +46,9 @@ module Karafka
 
           return @running_jobs unless @running_jobs.negative?
 
-          raise Karafka::Errors::InvalidCoordinatorState, @running_jobs
+          # This should never happen. If it does, something is heavily out of sync. Please reach
+          # out to us if you encounter this
+          raise Karafka::Errors::InvalidCoordinatorState, 'Was zero before decrementation'
         end
       end
 

data/lib/karafka/processing/coordinators_buffer.rb

@@ -2,7 +2,7 @@
 
 module Karafka
   module Processing
-    # Buffer used to build and store coordinators per topic partition
+    # Coordinators builder used to build coordinators per topic partition
     #
     # It provides direct pauses access for revocation
     #
@@ -34,17 +34,13 @@ module Karafka
       # @param topic [String] topic name
       # @param partition [Integer] partition number
       def revoke(topic, partition)
-        @pauses_manager.revoke(topic, partition)
+        return unless @coordinators[topic].key?(partition)
 
         # The fact that we delete here does not change the fact that the executor still holds the
         # reference to this coordinator. We delete it here, as we will no longer process any
         # new stuff with it and we may need a new coordinator if we regain this partition, but the
         # coordinator may still be in use
-        coordinator = @coordinators[topic].delete(partition)
-
-        return unless coordinator
-
-        coordinator.revoke
+        @coordinators[topic].delete(partition).revoke
       end
 
       # Clears coordinators and re-created the pauses manager

data/lib/karafka/processing/executor.rb

@@ -71,7 +71,7 @@ module Karafka
 
       # Runs consumer after consumption code
       def after_consume
-        consumer.on_after_consume if @consumer
+        consumer.on_after_consume
       end
 
       # Runs the controller `#revoked` method that should be triggered when a given consumer is

data/lib/karafka/processing/partitioner.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+module Karafka
+  module Processing
+    # Basic partitioner for work division
+    # It does not divide any work.
+    class Partitioner
+      # @param subscription_group [Karafka::Routing::SubscriptionGroup] subscription group
+      def initialize(subscription_group)
+        @subscription_group = subscription_group
+      end
+
+      # @param _topic [String] topic name
+      # @param messages [Array<Karafka::Messages::Message>] karafka messages
+      # @yieldparam [Integer] group id
+      # @yieldparam [Array<Karafka::Messages::Message>] karafka messages
+      def call(_topic, messages)
+        yield(0, messages)
+      end
+    end
+  end
+end

data/lib/karafka/setup/config.rb

@@ -107,6 +107,8 @@ module Karafka
           setting :jobs_builder, default: Processing::JobsBuilder.new
           # option coordinator [Class] work coordinator we want to user for processing coordination
           setting :coordinator_class, default: Processing::Coordinator
+          # option partitioner_class [Class] partitioner we use against a batch of data
+          setting :partitioner_class, default: Processing::Partitioner
         end
 
         # Karafka components for ActiveJob

data/lib/karafka/version.rb

@@ -3,5 +3,5 @@
 # Main module namespace
 module Karafka
   # Current Karafka version
-  VERSION = '2.0.0.beta5'
+  VERSION = '2.0.0.rc1'
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: karafka
 version: !ruby/object:Gem::Version
-  version: 2.0.0.beta5
+  version: 2.0.0.rc1
 platform: ruby
 authors:
 - Maciej Mensfeld
@@ -34,7 +34,7 @@ cert_chain:
   R2P11bWoCtr70BsccVrN8jEhzwXngMyI2gVt750Y+dbTu1KgRqZKp/ECe7ZzPzXj
   pIy9vHxTANKYVyI4qj8OrFdEM5BQNu8oQpL0iQ==
   -----END CERTIFICATE-----
-date: 2022-07-05 00:00:00.000000000 Z
+date: 2022-07-08 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: dry-configurable
@@ -240,6 +240,7 @@ files:
 - lib/karafka/pro/processing/coordinator.rb
 - lib/karafka/pro/processing/jobs/consume_non_blocking.rb
 - lib/karafka/pro/processing/jobs_builder.rb
+- lib/karafka/pro/processing/partitioner.rb
 - lib/karafka/pro/processing/scheduler.rb
 - lib/karafka/pro/routing/extensions.rb
 - lib/karafka/process.rb
@@ -253,6 +254,7 @@ files:
 - lib/karafka/processing/jobs/shutdown.rb
 - lib/karafka/processing/jobs_builder.rb
 - lib/karafka/processing/jobs_queue.rb
+- lib/karafka/processing/partitioner.rb
 - lib/karafka/processing/result.rb
 - lib/karafka/processing/scheduler.rb
 - lib/karafka/processing/worker.rb