karafka 1.4.0 → 2.0.10

data/lib/karafka/pro/active_job/consumer.rb

@@ -0,0 +1,46 @@
+# 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 ActiveJob
+      # Pro ActiveJob consumer that is suppose to handle long-running jobs as well as short
+      # running jobs
+      #
+      # When in LRJ, it will pause a given partition forever and will resume its processing only
+      # when all the jobs are done processing.
+      #
+      # It contains slightly better revocation warranties than the regular blocking consumer as
+      # it can stop processing batch of jobs in the middle after the revocation.
+      class Consumer < Karafka::Pro::BaseConsumer
+        # Runs ActiveJob jobs processing and handles lrj if needed
+        def consume
+          messages.each do |message|
+            # If for any reason we've lost this partition, not worth iterating over new messages
+            # as they are no longer ours
+            break if revoked?
+            break if Karafka::App.stopping?
+
+            ::ActiveJob::Base.execute(
+              ::ActiveSupport::JSON.decode(message.raw_payload)
+            )
+
+            # We cannot mark jobs as done after each if there are virtual partitions. Otherwise
+            # this could create random markings
+            next if topic.virtual_partitions?
+
+            mark_as_consumed(message)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/karafka/pro/active_job/dispatcher.rb

@@ -0,0 +1,61 @@
+# 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
+    # Karafka Pro ActiveJob components
+    module ActiveJob
+      # Pro dispatcher that sends the ActiveJob job to a proper topic based on the queue name
+      # and that allows to inject additional options into the producer, effectively allowing for a
+      # much better and more granular control over the dispatch and consumption process.
+      class Dispatcher < ::Karafka::ActiveJob::Dispatcher
+        # Defaults for dispatching
+        # They can be updated by using `#karafka_options` on the job
+        DEFAULTS = {
+          dispatch_method: :produce_async,
+          # We don't create a dummy proc based partitioner as we would have to evaluate it with
+          # each job.
+          partitioner: nil,
+          # Allows for usage of `:key` or `:partition_key`
+          partition_key_type: :key
+        }.freeze
+
+        private_constant :DEFAULTS
+
+        # @param job [ActiveJob::Base] job
+        def call(job)
+          ::Karafka.producer.public_send(
+            fetch_option(job, :dispatch_method, DEFAULTS),
+            dispatch_details(job).merge!(
+              topic: job.queue_name,
+              payload: ::ActiveSupport::JSON.encode(job.serialize)
+            )
+          )
+        end
+
+        private
+
+        # @param job [ActiveJob::Base] job instance
+        # @return [Hash] hash with dispatch details to which we merge topic and payload
+        def dispatch_details(job)
+          partitioner = fetch_option(job, :partitioner, DEFAULTS)
+          key_type = fetch_option(job, :partition_key_type, DEFAULTS)
+
+          return {} unless partitioner
+
+          {
+            key_type => partitioner.call(job)
+          }
+        end
+      end
+    end
+  end
+end

data/lib/karafka/pro/active_job/job_options_contract.rb

@@ -0,0 +1,32 @@
+# 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 ActiveJob
+      # Contract for validating the options that can be altered with `#karafka_options` per job
+      # class that works with Pro features.
+      class JobOptionsContract < Contracts::Base
+        configure do |config|
+          config.error_messages = YAML.safe_load(
+            File.read(
+              File.join(Karafka.gem_root, 'config', 'errors.yml')
+            )
+          ).fetch('en').fetch('validations').fetch('job_options')
+        end
+
+        optional(:dispatch_method) { |val| %i[produce_async produce_sync].include?(val) }
+        optional(:partitioner) { |val| val.respond_to?(:call) }
+        optional(:partition_key_type) { |val| %i[key partition_key].include?(val) }
+      end
+    end
+  end
+end

data/lib/karafka/pro/base_consumer.rb

@@ -0,0 +1,107 @@
+# 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
+    # Karafka PRO consumer.
+    #
+    # If you use PRO, all your consumers should inherit (indirectly) from it.
+    #
+    # @note In case of using lrj, manual pausing may not be the best idea as resume needs to happen
+    #   after each batch is processed.
+    class BaseConsumer < Karafka::BaseConsumer
+      # Pause for tops 31 years
+      MAX_PAUSE_TIME = 1_000_000_000_000
+
+      private_constant :MAX_PAUSE_TIME
+
+      # 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`
+      # @note This needs to happen in the listener thread, because we cannot wait on this being
+      #   executed in the workers. Workers may be already running some LRJ jobs that are blocking
+      #   all the threads until finished, yet unless we pause the incoming partitions information,
+      #   we may be kicked out of the consumer group due to not polling often enough
+      def on_before_enqueue
+        return unless topic.long_running_job?
+
+        # This ensures that when running LRJ with VP, things operate as expected run only once
+        # for all the virtual partitions collectively
+        coordinator.on_enqueued do
+          # Pause at the first message in a batch. That way in case of a crash, we will not loose
+          # any messages.
+          #
+          # For VP it applies the same way and since VP cannot be used with MOM we should not have
+          # any edge cases here.
+          pause(coordinator.seek_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
+        coordinator.on_finished do |last_group_message|
+          on_after_consume_regular(last_group_message)
+        end
+      end
+
+      # Trigger method for running on partition revocation.
+      #
+      # @private
+      def on_revoked
+        # We do not want to resume on revocation in case of a LRJ.
+        # For LRJ we resume after the successful processing or do a backoff pause in case of a
+        # failure. Double non-blocking resume could cause problems in coordination.
+        resume unless topic.long_running_job?
+
+        coordinator.revoke
+
+        Karafka.monitor.instrument('consumer.revoked', caller: self) do
+          revoked
+        end
+      rescue StandardError => e
+        Karafka.monitor.instrument(
+          'error.occurred',
+          error: e,
+          caller: self,
+          type: 'consumer.revoked.error'
+        )
+      end
+
+      private
+
+      # Handles the post-consumption flow depending on topic settings
+      #
+      # @param last_group_message [Karafka::Messages::Message]
+      def on_after_consume_regular(last_group_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(last_group_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?
+
+          seek(coordinator.seek_offset) unless revoked?
+
+          resume
+        else
+          # If processing failed, we need to pause
+          # For long running job this will overwrite the default never-ending pause and will cause
+          # the processing to keep going after the error backoff
+          pause(coordinator.seek_offset)
+        end
+      end
+    end
+  end
+end

data/lib/karafka/pro/contracts/base.rb

@@ -0,0 +1,21 @@
+# 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
+    # Namespace for Karafka Pro related contracts
+    module Contracts
+      # Base contract for Pro components contracts
+      class Base < ::Karafka::Contracts::Base
+      end
+    end
+  end
+end

data/lib/karafka/pro/contracts/consumer_group.rb

@@ -0,0 +1,34 @@
+# 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 Contracts
+      # Contract for validating correct Pro components setup on a consumer group and topic levels
+      class ConsumerGroup < Base
+        virtual do |data, errors|
+          next unless errors.empty?
+          next unless data.key?(:topics)
+
+          fetched_errors = []
+
+          data.fetch(:topics).each do |topic|
+            ConsumerGroupTopic.new.call(topic).errors.each do |key, value|
+              fetched_errors << [[topic, key].flatten, value]
+            end
+          end
+
+          fetched_errors
+        end
+      end
+    end
+  end
+end

data/lib/karafka/pro/contracts/consumer_group_topic.rb

@@ -0,0 +1,69 @@
+# 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 Contracts
+      # Contract for validating correct Pro components setup on a topic levels
+      class ConsumerGroupTopic < Base
+        configure do |config|
+          config.error_messages = YAML.safe_load(
+            File.read(
+              File.join(Karafka.gem_root, 'config', 'errors.yml')
+            )
+          ).fetch('en').fetch('validations').fetch('pro_consumer_group_topic')
+        end
+
+        nested(:virtual_partitions) do
+          required(:active) { |val| [true, false].include?(val) }
+          required(:partitioner) { |val| val.nil? || val.respond_to?(:call) }
+          required(:max_partitions) { |val| val.is_a?(Integer) && val >= 1 }
+        end
+
+        virtual do |data, errors|
+          next unless errors.empty?
+          next if data[:consumer] < Karafka::Pro::BaseConsumer
+
+          [[%i[consumer], :consumer_format]]
+        end
+
+        # When virtual partitions are defined, partitioner needs to respond to `#call` and it
+        # cannot be nil
+        virtual do |data, errors|
+          next unless errors.empty?
+
+          virtual_partitions = data[:virtual_partitions]
+
+          next unless virtual_partitions[:active]
+          next if virtual_partitions[:partitioner].respond_to?(:call)
+
+          [[%i[virtual_partitions partitioner], :respond_to_call]]
+        end
+
+        # Make sure that manual offset management is not used together with Virtual Partitions
+        # This would not make any sense as there would be edge cases related to skipping
+        # messages even if there were errors.
+        virtual do |data, errors|
+          next unless errors.empty?
+
+          virtual_partitions = data[:virtual_partitions]
+          manual_offset_management = data[:manual_offset_management]
+
+          next unless virtual_partitions[:active]
+          next unless manual_offset_management
+          next if data[:tags].include?(:active_job)
+
+          [[%i[manual_offset_management], :not_with_virtual_partitions]]
+        end
+      end
+    end
+  end
+end

data/lib/karafka/pro/loader.rb

@@ -0,0 +1,76 @@
+# 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
+    # Loader requires and loads all the pro components only when they are needed
+    class Loader
+      # All the pro components that need to be loaded
+      COMPONENTS = %w[
+        base_consumer
+        performance_tracker
+        processing/scheduler
+        processing/jobs/consume_non_blocking
+        processing/jobs_builder
+        processing/coordinator
+        processing/partitioner
+        contracts/base
+        contracts/consumer_group
+        contracts/consumer_group_topic
+        routing/topic_extensions
+        routing/builder_extensions
+        active_job/consumer
+        active_job/dispatcher
+        active_job/job_options_contract
+      ].freeze
+
+      private_constant :COMPONENTS
+
+      class << self
+        # Loads all the pro components and configures them wherever it is expected
+        # @param config [Karafka::Core::Configurable::Node] app config that we can alter with pro
+        #   components
+        def setup(config)
+          COMPONENTS.each { |component| require_relative(component) }
+
+          reconfigure(config)
+
+          load_routing_extensions
+        end
+
+        private
+
+        # Sets proper config options to use pro components
+        # @param config [WaterDrop::Configurable::Node] root config node
+        def reconfigure(config)
+          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
+
+          icfg.active_job.consumer_class = ActiveJob::Consumer
+          icfg.active_job.dispatcher = ActiveJob::Dispatcher.new
+          icfg.active_job.job_options_contract = ActiveJob::JobOptionsContract.new
+
+          config.monitor.subscribe(PerformanceTracker.instance)
+        end
+
+        # Loads routing extensions
+        def load_routing_extensions
+          ::Karafka::Routing::Topic.prepend(Routing::TopicExtensions)
+          ::Karafka::Routing::Builder.prepend(Routing::BuilderExtensions)
+        end
+      end
+    end
+  end
+end

data/lib/karafka/pro/performance_tracker.rb

@@ -0,0 +1,80 @@
+# 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
+    # Tracker used to keep track of performance metrics
+    # It provides insights that can be used to optimize processing flow
+    class PerformanceTracker
+      include Singleton
+
+      # How many samples do we collect per topic partition
+      SAMPLES_COUNT = 200
+
+      private_constant :SAMPLES_COUNT
+
+      # Builds up nested concurrent hash for data tracking
+      def initialize
+        @processing_times = Concurrent::Hash.new do |topics_hash, topic|
+          topics_hash[topic] = Concurrent::Hash.new do |partitions_hash, partition|
+            # This array does not have to be concurrent because we always access single partition
+            # data via instrumentation that operates in a single thread via consumer
+            partitions_hash[partition] = []
+          end
+        end
+      end
+
+      # @param topic [String]
+      # @param partition [Integer]
+      # @return [Float] p95 processing time of a single message from a single topic partition
+      def processing_time_p95(topic, partition)
+        values = @processing_times[topic][partition]
+
+        return 0 if values.empty?
+        return values.first if values.size == 1
+
+        percentile(0.95, values)
+      end
+
+      # @private
+      # @param event [Karafka::Core::Monitoring::Event] event details
+      # Tracks time taken to process a single message of a given topic partition
+      def on_consumer_consumed(event)
+        consumer = event[:caller]
+        messages = consumer.messages
+        topic = messages.metadata.topic
+        partition = messages.metadata.partition
+
+        samples = @processing_times[topic][partition]
+        samples << event[:time] / messages.count
+
+        return unless samples.size > SAMPLES_COUNT
+
+        samples.shift
+      end
+
+      private
+
+      # Computers the requested percentile out of provided values
+      # @param percentile [Float]
+      # @param values [Array<String>] all the values based on which we should
+      # @return [Float] computed percentile
+      def percentile(percentile, values)
+        values_sorted = values.sort
+
+        floor = (percentile * (values_sorted.length - 1) + 1).floor - 1
+        mod = (percentile * (values_sorted.length - 1) + 1).modulo(1)
+
+        values_sorted[floor] + (mod * (values_sorted[floor + 1] - values_sorted[floor]))
+      end
+    end
+  end
+end

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

@@ -0,0 +1,85 @@
+# 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 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_enqueued_invoked = false
+          @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_enqueued_invoked = false
+            @on_started_invoked = false
+            @on_finished_invoked = false
+            @last_message = messages.last
+          end
+        end
+
+        # @return [Boolean] is the coordinated work finished or not
+        def finished?
+          @running_jobs.zero?
+        end
+
+        # Runs synchronized code once for a collective of virtual partitions prior to work being
+        # enqueued
+        def on_enqueued
+          @flow_lock.synchronize do
+            return if @on_enqueued_invoked
+
+            @on_enqueued_invoked = true
+
+            yield(@last_message)
+          end
+        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(@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(@last_message)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/karafka/pro/processing/jobs/consume_non_blocking.rb

@@ -0,0 +1,38 @@
+# 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
+    # Pro components related to processing part of Karafka
+    module Processing
+      # Pro jobs
+      module Jobs
+        # The main job type in a non-blocking variant.
+        # This variant works "like" the regular consumption but pauses the partition for as long
+        # as it is needed until a job is done.
+        #
+        # It can be useful when having long lasting jobs that would exceed `max.poll.interval`
+        # if would block.
+        #
+        # @note It needs to be working with a proper consumer that will handle the partition
+        #   management. This layer of the framework knows nothing about Kafka messages consumption.
+        class ConsumeNonBlocking < ::Karafka::Processing::Jobs::Consume
+          # Makes this job non-blocking from the start
+          # @param args [Array] any arguments accepted by `::Karafka::Processing::Jobs::Consume`
+          def initialize(*args)
+            super
+            @non_blocking = true
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,32 @@
+# 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 jobs builder that supports lrj
+      class JobsBuilder < ::Karafka::Processing::JobsBuilder
+        # @param executor [Karafka::Processing::Executor]
+        # @param messages [Karafka::Messages::Messages] messages batch to be consumed
+        # @param coordinator [Karafka::Processing::Coordinator]
+        # @return [Karafka::Processing::Jobs::Consume] blocking job
+        # @return [Karafka::Pro::Processing::Jobs::ConsumeNonBlocking] non blocking for lrj
+        def consume(executor, messages, coordinator)
+          if executor.topic.long_running_job?
+            Jobs::ConsumeNonBlocking.new(executor, messages, coordinator)
+          else
+            super
+          end
+        end
+      end
+    end
+  end
+end