karafka 1.1.2 → 1.2.0.beta1

data/lib/karafka/callbacks.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+module Karafka
+  # Additional callbacks that are used to trigger some things in given places during the
+  # system lifecycle
+  # @note Those callbacks aren't the same as consumer callbacks as they are not related to the
+  #   lifecycle of particular messages fetches but rather to the internal flow process.
+  #   They cannot be defined on a consumer callback level because for some of those,
+  #   there aren't consumers in the memory yet and/or they aren't per consumer thread
+  module Callbacks
+    # Types of system callbacks that we have that are not related to consumers
+    TYPES = %i[
+      after_init
+      before_fetch_loop
+    ].freeze
+
+    class << self
+      TYPES.each do |callback_type|
+        # Executes given callbacks set at a given moment with provided arguments
+        define_method callback_type do |*args|
+          Karafka::App
+            .config
+            .callbacks
+            .send(callback_type)
+            .each { |block| block.call(*args) }
+        end
+      end
+    end
+  end
+end

data/lib/karafka/callbacks/config.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+module Karafka
+  module Callbacks
+    # Additional configuration required to store procs that we will execute upon callback trigger
+    module Config
+      # Builds up internal callback accumulators
+      # @param klass [Class] Class that we extend with callback config
+      def self.extended(klass)
+        # option internal [Hash] - optional - internal karafka configuration settings that should
+        #   never be changed by users directly
+        klass.setting :callbacks do
+          Callbacks::TYPES.each do |callback_type|
+            # option [Array<Proc>] an array of blocks that will be executed at a given moment
+            #   depending on the callback type
+            setting callback_type, []
+          end
+        end
+      end
+    end
+  end
+end

data/lib/karafka/callbacks/dsl.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+module Karafka
+  module Callbacks
+    # App level dsl to define callbacks
+    module Dsl
+      Callbacks::TYPES.each do |callback_type|
+        # Allows us to define a block, that will be executed for a given moment
+        # @param [Block] block that should be executed after the initialization process
+        define_method callback_type do |&block|
+          config.callbacks.send(callback_type).push block
+        end
+      end
+    end
+  end
+end

data/lib/karafka/cli/install.rb

@@ -9,8 +9,7 @@ module Karafka
 
       # Directories created by default
       INSTALL_DIRS = %w[
-        app/models
-        app/controllers
+        app/consumers
         app/responders
         config
         log
@@ -20,7 +19,7 @@ module Karafka
       # Where should we map proper files from templates
       INSTALL_FILES_MAP = {
         'karafka.rb.example' => Karafka.boot_file.basename,
-        'application_controller.rb.example' => 'app/controllers/application_controller.rb',
+        'application_consumer.rb.example' => 'app/consumers/application_consumer.rb',
         'application_responder.rb.example' => 'app/responders/application_responder.rb'
       }.freeze
 

data/lib/karafka/cli/server.rb

@@ -35,7 +35,6 @@ module Karafka
         # won't alarm or start new system process up until the current one is finished
         ObjectSpace.define_finalizer(self, proc { send(:clean) })
 
-        # After we fork, we can boot celluloid again
         Karafka::Server.run
       end
 

data/lib/karafka/connection/{consumer.rb → client.rb}

@@ -2,37 +2,50 @@
 
 module Karafka
   module Connection
-    # Class used as a wrapper around Ruby-Kafka to simplify additional
+    # Class used as a wrapper around Ruby-Kafka client to simplify additional
     # features that we provide/might provide in future and to hide the internal implementation
-    class Consumer
-      # Creates a queue consumer that will pull the data from Kafka
+    class Client
+      extend Forwardable
+
+      def_delegator :kafka_consumer, :seek
+
+      # Creates a queue consumer client that will pull the data from Kafka
       # @param consumer_group [Karafka::Routing::ConsumerGroup] consumer group for which
       #   we create a client
-      # @return [Karafka::Connection::Consumer] group consumer that can subscribe to
+      # @return [Karafka::Connection::Client] group consumer that can subscribe to
       #   multiple topics
       def initialize(consumer_group)
         @consumer_group = consumer_group
-        Persistence::Consumer.write(self)
+        Persistence::Client.write(self)
       end
 
       # Opens connection, gets messages and calls a block for each of the incoming messages
       # @yieldparam [Array<Kafka::FetchedMessage>] kafka fetched messages
       # @note This will yield with raw messages - no preprocessing or reformatting.
       def fetch_loop
-        send(
-          consumer_group.batch_fetching ? :consume_each_batch : :consume_each_message
-        ) { |messages| yield(messages) }
+        settings = ConfigAdapter.consuming(consumer_group)
+
+        if consumer_group.batch_fetching
+          kafka_consumer.each_batch(*settings) { |batch| yield(batch.messages) }
+        else
+          # always yield an array of messages, so we have consistent API (always a batch)
+          kafka_consumer.each_message(*settings) { |message| yield([message]) }
+        end
       rescue Kafka::ProcessingError => e
         # If there was an error during consumption, we have to log it, pause current partition
         # and process other things
-        Karafka.monitor.notice_error(self.class, e.cause)
+        Karafka.monitor.instrument(
+          'connection.client.fetch_loop.error',
+          caller: self,
+          error: e.cause
+        )
         pause(e.topic, e.partition)
         retry
         # This is on purpose - see the notes for this method
         # rubocop:disable RescueException
       rescue Exception => e
         # rubocop:enable RescueException
-        Karafka.monitor.notice_error(self.class, e)
+        Karafka.monitor.instrument('connection.client.fetch_loop.error', caller: self, error: e)
         retry
       end
 
@@ -70,32 +83,11 @@ module Karafka
 
       attr_reader :consumer_group
 
-      # Consumes messages from Kafka in batches
-      # @yieldparam [Array<Kafka::FetchedMessage>] kafka fetched messages
-      def consume_each_batch
-        kafka_consumer.each_batch(
-          ConfigAdapter.consuming(consumer_group)
-        ) do |batch|
-          yield(batch.messages)
-        end
-      end
-
-      # Consumes messages from Kafka one by one
-      # @yieldparam [Array<Kafka::FetchedMessage>] kafka fetched messages
-      def consume_each_message
-        kafka_consumer.each_message(
-          ConfigAdapter.consuming(consumer_group)
-        ) do |message|
-          #   always yield an array of messages, so we have consistent API (always a batch)
-          yield([message])
-        end
-      end
-
       # @return [Kafka::Consumer] returns a ready to consume Kafka consumer
       #   that is set up to consume from topics of a given consumer group
       def kafka_consumer
         @kafka_consumer ||= kafka.consumer(
-          ConfigAdapter.consumer(consumer_group)
+          *ConfigAdapter.consumer(consumer_group)
         ).tap do |consumer|
           consumer_group.topics.each do |topic|
             consumer.subscribe(*ConfigAdapter.subscription(topic))
@@ -114,7 +106,7 @@ module Karafka
       # @note We don't cache it internally because we cache kafka_consumer that uses kafka
       #   object instance
       def kafka
-        Kafka.new(ConfigAdapter.client(consumer_group))
+        Kafka.new(*ConfigAdapter.client(consumer_group))
       end
     end
   end

data/lib/karafka/connection/config_adapter.rb

@@ -14,7 +14,10 @@ module Karafka
       class << self
         # Builds all the configuration settings for Kafka.new method
         # @param _consumer_group [Karafka::Routing::ConsumerGroup] consumer group details
-        # @return [Hash] hash with all the settings required by Kafka.new method
+        # @return [Array<Hash>] Array with all the client arguments including hash with all
+        #   the settings required by Kafka.new method
+        # @note We return array, so we can inject any arguments we want, in case of changes in the
+        #   raw driver
         def client(_consumer_group)
           # This one is a default that takes all the settings except special
           # cases defined in the map
@@ -33,28 +36,33 @@ module Karafka
             settings[setting_name] = setting_value
           end
 
-          sanitize(settings)
+          settings_hash = sanitize(settings)
+
+          # Normalization for the way Kafka::Client accepts arguments from  0.5.3
+          [settings_hash.delete(:seed_brokers), settings_hash]
         end
 
         # Builds all the configuration settings for kafka#consumer method
         # @param consumer_group [Karafka::Routing::ConsumerGroup] consumer group details
-        # @return [Hash] hash with all the settings required by Kafka#consumer method
+        # @return [Array<Hash>] array with all the consumer arguments including hash with all
+        #   the settings required by Kafka#consumer
         def consumer(consumer_group)
           settings = { group_id: consumer_group.id }
           settings = fetch_for(:consumer, consumer_group, settings)
-          sanitize(settings)
+          [sanitize(settings)]
         end
 
         # Builds all the configuration settings for kafka consumer consume_each_batch and
         #   consume_each_message methods
         # @param consumer_group [Karafka::Routing::ConsumerGroup] consumer group details
-        # @return [Hash] hash with all the settings required by
+        # @return [Array<Hash>] Array with all the arguments required by consuming method
+        #   including hash with all the settings required by
         #   Kafka::Consumer#consume_each_message and Kafka::Consumer#consume_each_batch method
         def consuming(consumer_group)
           settings = {
             automatically_mark_as_processed: consumer_group.automatically_mark_as_consumed
           }
-          sanitize(fetch_for(:consuming, consumer_group, settings))
+          [sanitize(fetch_for(:consuming, consumer_group, settings))]
         end
 
         # Builds all the configuration settings for kafka consumer#subscribe method

data/lib/karafka/connection/delegator.rb

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+module Karafka
+  module Connection
+    # Class that delegates processing of messages for which we listen to a proper processor
+    module Delegator
+      class << self
+        # Delegates messages (does something with them)
+        # It will either schedule or run a proper processor action for messages
+        # @note This should be looped to obtain a constant delegating of new messages
+        # @note We catch all the errors here, to make sure that none failures
+        #   for a given consumption will affect other consumed messages
+        #   If we wouldn't catch it, it would propagate up until killing the thread
+        # @note It is a one huge method, because of performance reasons. It is much faster then
+        #   using send or invoking additional methods
+        # @param group_id [String] group_id of a group from which a given message came
+        # @param kafka_messages [Array<Kafka::FetchedMessage>] raw messages fetched from kafka
+        def call(group_id, kafka_messages)
+          # @note We always get messages by topic and partition so we can take topic from the
+          # first one and it will be valid for all the messages
+          topic = Persistence::Topic.fetch(group_id, kafka_messages[0].topic)
+          consumer = Persistence::Consumer.fetch(topic, kafka_messages[0].partition)
+
+          Karafka.monitor.instrument(
+            'connection.delegator.call',
+            caller: self,
+            consumer: consumer,
+            kafka_messages: kafka_messages
+          ) do
+            # Depending on a case (persisted or not) we might use new consumer instance per
+            # each batch, or use the same one for all of them (for implementing buffering, etc.)
+            if topic.batch_consuming
+              consumer.params_batch = kafka_messages
+              consumer.call
+            else
+              kafka_messages.each do |kafka_message|
+                consumer.params_batch = [kafka_message]
+                consumer.call
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/karafka/connection/listener.rb

@@ -7,8 +7,6 @@ module Karafka
     # @note Listener itself does nothing with the message - it will return to the block
     #   a raw Kafka::FetchedMessage
     class Listener
-      attr_reader :consumer_group
-
       # @param consumer_group [Karafka::Routing::ConsumerGroup] consumer group that holds details
       #   on what topics and with what settings should we listen
       # @return [Karafka::Connection::Listener] listener instance
@@ -16,6 +14,17 @@ module Karafka
         @consumer_group = consumer_group
       end
 
+      # Runs prefetch callbacks and executes the main listener fetch loop
+      def call
+        Karafka::Callbacks.before_fetch_loop(
+          @consumer_group,
+          client
+        )
+        fetch_loop
+      end
+
+      private
+
       # Opens connection, gets messages and calls a block for each of the incoming messages
       # @yieldparam [String] consumer group id
       # @yieldparam [Array<Kafka::FetchedMessage>] kafka fetched messages
@@ -26,25 +35,25 @@ module Karafka
       #   won't crash the whole cluster. Here we mostly focus on catchin the exceptions related to
       #   Kafka connections / Internet connection issues / Etc. Business logic problems should not
       #   propagate this far
-      def fetch_loop(block)
-        consumer.fetch_loop do |raw_messages|
-          block.call(consumer_group.id, raw_messages)
+      def fetch_loop
+        client.fetch_loop do |raw_messages|
+          # @note What happens here is a delegation of processing to a proper processor based
+          #   on the incoming messages characteristics
+          Karafka::Connection::Delegator.call(@consumer_group.id, raw_messages)
         end
         # This is on purpose - see the notes for this method
         # rubocop:disable RescueException
       rescue Exception => e
+        Karafka.monitor.instrument('connection.listener.fetch_loop.error', caller: self, error: e)
         # rubocop:enable RescueException
-        Karafka.monitor.notice_error(self.class, e)
-        @consumer&.stop
-        retry if @consumer
+        @client&.stop
+        retry if @client
       end
 
-      private
-
-      # @return [Karafka::Connection::Consumer] wrapped kafka consumer for a given topic
+      # @return [Karafka::Connection::Client] wrapped kafka consuming client for a given topic
       #   consumption
-      def consumer
-        @consumer ||= Consumer.new(consumer_group)
+      def client
+        @client ||= Client.new(@consumer_group)
       end
     end
   end

data/lib/karafka/{controllers → consumers}/callbacks.rb

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 
 module Karafka
-  module Controllers
+  module Consumers
     # Additional callbacks that can be used to trigger some actions on certain moments like
     # manual offset management, committing or anything else outside of a standard messages flow
     # They are not included by default, as we don't want to provide functionalities that are
@@ -10,7 +10,7 @@ module Karafka
     module Callbacks
       # Types of events on which we run callbacks
       TYPES = %i[
-        after_fetched
+        after_fetch
         after_poll
         before_poll
         before_stop
@@ -28,9 +28,9 @@ module Karafka
         end
       end
 
-      # @param controller_class [Class] controller class that we extend with callbacks
-      def self.included(controller_class)
-        controller_class.class_eval do
+      # @param consumer_class [Class] consumer class that we extend with callbacks
+      def self.included(consumer_class)
+        consumer_class.class_eval do
           extend ClassMethods
           include ActiveSupport::Callbacks
 
@@ -41,11 +41,11 @@ module Karafka
         end
       end
 
-      # Executes the default controller flow, runs callbacks and if not halted will call process
-      # method of a proper backend. This is here because it interacts with the default Karafka
-      # call flow and needs to be overwritten in order to support callbacks
+      # Executes the default consumer flow, runs callbacks and if not halted will call process
+      # method of a proper backend. It is here because it interacts with the default Karafka
+      # call flow and needs to be overwritten to support callbacks
       def call
-        run_callbacks :after_fetched do
+        run_callbacks :after_fetch do
           process
         end
       end

data/lib/karafka/consumers/includer.rb

@@ -0,0 +1,51 @@
+# frozen_string_literal: true
+
+module Karafka
+  # Additional functionalities for consumers
+  module Consumers
+    # Module used to inject functionalities into a given consumer class, based on the consumer
+    # topic and its settings
+    # We don't need all the behaviors in all the cases, so it is not worth having everything
+    # in all the cases all the time
+    module Includer
+      class << self
+        # @param consumer_class [Class] consumer class, that will get some functionalities
+        #   based on the topic under which it operates
+        def call(consumer_class)
+          topic = consumer_class.topic
+
+          bind_backend(consumer_class, topic)
+          bind_params(consumer_class, topic)
+          bind_responders(consumer_class, topic)
+        end
+
+        private
+
+        # Figures out backend for a given consumer class, based on the topic backend and
+        #   includes it into the consumer class
+        # @param consumer_class [Class] consumer class
+        # @param topic [Karafka::Routing::Topic] topic of a consumer class
+        def bind_backend(consumer_class, topic)
+          backend = Kernel.const_get("::Karafka::Backends::#{topic.backend.to_s.capitalize}")
+          consumer_class.include backend
+        end
+
+        # Adds a single #params support for non batch processed topics
+        # @param consumer_class [Class] consumer class
+        # @param topic [Karafka::Routing::Topic] topic of a consumer class
+        def bind_params(consumer_class, topic)
+          return if topic.batch_consuming
+          consumer_class.include SingleParams
+        end
+
+        # Adds responders support for topics and consumers with responders defined for them
+        # @param consumer_class [Class] consumer class
+        # @param topic [Karafka::Routing::Topic] topic of a consumer class
+        def bind_responders(consumer_class, topic)
+          return unless topic.responder
+          consumer_class.include Responders
+        end
+      end
+    end
+  end
+end