karafka 1.1.2 → 1.2.0.beta1

data/lib/karafka/consumers/responders.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+module Karafka
+  module Consumers
+    # Feature that allows us to use responders flow in consumer
+    module Responders
+      # Responds with given data using given responder. This allows us to have a similar way of
+      # defining flows like synchronous protocols
+      # @param data Anything we want to pass to responder based on which we want to trigger further
+      #   Kafka responding
+      def respond_with(*data)
+        Karafka.monitor.instrument(
+          'consumers.responders.respond_with',
+          caller: self,
+          data: data
+        ) do
+          # @note we build a new instance of responder each time, as a long-running (persisted)
+          #   consumers can respond multiple times during the lifecycle
+          topic.responder.new(topic.parser).call(*data)
+        end
+      end
+    end
+  end
+end

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

@@ -1,12 +1,12 @@
 # frozen_string_literal: true
 
 module Karafka
-  module Controllers
-    # Params alias for single message consumption controllers
+  module Consumers
+    # Params alias for single message consumption consumers
     module SingleParams
       private
 
-      # @return [Karafka::Params::Params] params instance for non batch consumption controllers
+      # @return [Karafka::Params::Params] params instance for non batch consumption consumers
       def params
         params_batch.first
       end

data/lib/karafka/errors.rb

@@ -13,9 +13,9 @@ module Karafka
 
     # Raised when router receives topic name which does not correspond with any routes
     # This can only happen in a case when:
-    #   - you've received a message and we cannot match it with a controller
+    #   - you've received a message and we cannot match it with a consumer
     #   - you've changed the routing, so router can no longer associate your topic to
-    #     any controller
+    #     any consumer
     #   - or in a case when you do a lot of metaprogramming and you change routing/etc on runtime
     #
     # In case this happens, you will have to create a temporary route that will allow
@@ -27,6 +27,10 @@ module Karafka
     # topics usage definitions
     InvalidResponderUsage = Class.new(BaseError)
 
+    # Raised when options that we provide to the responder to respond aren't what the schema
+    # requires
+    InvalidResponderMessageOptions = Class.new(BaseError)
+
     # Raised when configuration doesn't match with validation schema
     InvalidConfiguration = Class.new(BaseError)
 
@@ -35,9 +39,12 @@ module Karafka
 
     # Raised when we want to read a persisted thread messages consumer but it is unavailable
     # This should never happen and if it does, please contact us
-    MissingConsumer = Class.new(BaseError)
+    MissingClient = Class.new(BaseError)
 
     # Raised when we attemp to pause a partition but the pause timeout is equal to 0
     InvalidPauseTimeout = Class.new(BaseError)
+
+    # Raised when want to hook up to an event that is not registered and supported
+    UnregisteredMonitorEvent = Class.new(BaseError)
   end
 end

data/lib/karafka/fetcher.rb

@@ -5,43 +5,39 @@ module Karafka
   # @note Creating multiple fetchers will result in having multiple connections to the same
   #   topics, which means that if there are no partitions, it won't use them.
   class Fetcher
-    # Starts listening on all the listeners asynchronously
-    # Fetch loop should never end, which means that we won't create more actor clusters
-    # so we don't have to terminate them
-    def fetch_loop
-      threads = listeners.map do |listener|
-        # We abort on exception because there should be an exception handling developed for
-        # each listener running in separate threads, so the exceptions should never leak
-        # and if that happens, it means that something really bad happened and we should stop
-        # the whole process
-        Thread
-          .new { listener.fetch_loop(processor) }
-          .tap { |thread| thread.abort_on_exception = true }
-      end
-
-      threads.each(&:join)
-    # If anything crashes here, we need to raise the error and crush the runner because it means
-    # that something really bad happened
-    rescue StandardError => e
-      Karafka.monitor.notice_error(self.class, e)
-      Karafka::App.stop!
-      raise e
-    end
+    class << self
+      # Starts listening on all the listeners asynchronously
+      # Fetch loop should never end, which means that we won't create more actor clusters
+      # so we don't have to terminate them
+      def call
+        threads = listeners.map do |listener|
+          # We abort on exception because there should be an exception handling developed for
+          # each listener running in separate threads, so the exceptions should never leak
+          # and if that happens, it means that something really bad happened and we should stop
+          # the whole process
+          Thread
+            .new { listener.call }
+            .tap { |thread| thread.abort_on_exception = true }
+        end
 
-    private
-
-    # @return [Array<Karafka::Connection::Listener>] listeners that will consume messages
-    def listeners
-      @listeners ||= App.consumer_groups.active.map do |consumer_group|
-        Karafka::Connection::Listener.new(consumer_group)
+        # We aggregate threads here for a supervised shutdown process
+        threads.each { |thread| Karafka::Server.consumer_threads << thread }
+        threads.each(&:join)
+      # If anything crashes here, we need to raise the error and crush the runner because it means
+      # that something terrible happened
+      rescue StandardError => e
+        Karafka.monitor.instrument('fetcher.call.error', caller: self, error: e)
+        Karafka::App.stop!
+        raise e
       end
-    end
 
-    # @return [Proc] proc that should be processed when a messages arrive
-    # @yieldparam messages [Array<Kafka::FetchedMessage>] messages from kafka (raw)
-    def processor
-      lambda do |group_id, messages|
-        Karafka::Connection::Processor.process(group_id, messages)
+      private
+
+      # @return [Array<Karafka::Connection::Listener>] listeners that will consume messages
+      def listeners
+        @listeners ||= App.consumer_groups.active.map do |consumer_group|
+          Karafka::Connection::Listener.new(consumer_group)
+        end
       end
     end
   end

data/lib/karafka/helpers/class_matcher.rb

@@ -4,20 +4,20 @@ module Karafka
   module Helpers
     # Class used to autodetect corresponding classes that are internally inside Karafka framework
     # It is used among others to match:
-    #   controller => responder
+    #   consumer => responder
     class ClassMatcher
-      # Regexp used to remove any non classy like characters that might be in the controller
+      # Regexp used to remove any non classy like characters that might be in the consumer
       # class name (if defined dynamically, etc)
       CONSTANT_REGEXP = %r{[?!=+\-\*/\^\|&\[\]<>%~\#\:\s\(\)]}
 
       # @param klass [Class] class to which we want to find a corresponding class
       # @param from [String] what type of object is it (based on postfix name part)
       # @param to [String] what are we looking for (based on a postfix name part)
-      # @example Controller that has a corresponding responder
-      #   matcher = Karafka::Helpers::ClassMatcher.new(SuperController, 'Controller', 'Responder')
+      # @example Consumer that has a corresponding responder
+      #   matcher = Karafka::Helpers::ClassMatcher.new(SuperConsumer, 'Consumer', 'Responder')
       #   matcher.match #=> SuperResponder
-      # @example Controller without a corresponding responder
-      #   matcher = Karafka::Helpers::ClassMatcher.new(Super2Controller, 'Controller', 'Responder')
+      # @example Consumer without a corresponding responder
+      #   matcher = Karafka::Helpers::ClassMatcher.new(Super2Consumer, 'Consumer', 'Responder')
       #   matcher.match #=> nil
       def initialize(klass, from:, to:)
         @klass = klass
@@ -36,9 +36,9 @@ module Karafka
 
       # @return [String] name of a new class that we're looking for
       # @note This method returns name of a class without a namespace
-      # @example From SuperController matching responder
+      # @example From SuperConsumer matching responder
       #   matcher.name #=> 'SuperResponder'
-      # @example From Namespaced::Super2Controller matching responder
+      # @example From Namespaced::Super2Consumer matching responder
       #   matcher.name #=> Super2Responder
       def name
         inflected = @klass.to_s.split('::').last.to_s

data/lib/karafka/helpers/config_retriever.rb

@@ -33,9 +33,9 @@ module Karafka
           return current_value unless current_value.nil?
 
           value = if Karafka::App.config.respond_to?(attribute)
-                    Karafka::App.config.public_send(attribute)
+                    Karafka::App.config.send(attribute)
                   else
-                    Karafka::App.config.kafka.public_send(attribute)
+                    Karafka::App.config.kafka.send(attribute)
                   end
 
           instance_variable_set(:"@#{attribute}", value)

data/lib/karafka/instrumentation/listener.rb

@@ -0,0 +1,97 @@
+# frozen_string_literal: true
+
+module Karafka
+  module Instrumentation
+    # Default listener that hooks up to our instrumentation and uses its events for logging
+    # It can be removed/replaced or anything without any harm to the Karafka app flow
+    module Listener
+      # Log levels that we use in this particular listener
+      USED_LOG_LEVELS = %i[
+        debug
+        info
+        error
+        fatal
+      ].freeze
+
+      # Injects WaterDrop listener logger actions
+      extend WaterDrop::Instrumentation::Listener
+
+      class << self
+        # Logs details about incoming messages and with which consumer we will consume them
+        # @param event [Dry::Events::Event] event details including payload
+        def on_connection_delegator_call(event)
+          consumer = event[:consumer]
+          topic = consumer.topic.name
+          kafka_messages = event[:kafka_messages]
+          info "#{kafka_messages.count} messages on #{topic} topic delegated to #{consumer.class}"
+        end
+
+        # Logs details about each received message value parsing
+        # @param event [Dry::Events::Event] event details including payload
+        def on_params_params_parse(event)
+          # Keep in mind, that a caller here is a param object not a controller,
+          # so it returns a topic as a string, not a routing topic
+          debug "Params parsing for #{event[:caller].topic} topic successful in #{event[:time]} ms"
+        end
+
+        # Logs unsuccessful parsing attempts of incoming data
+        # @param event [Dry::Events::Event] event details including payload
+        def on_params_params_parse_error(event)
+          error "Params parsing error for #{event[:caller].topic} topic: #{event[:error]}"
+        end
+
+        # Logs errors that occured in a listener fetch loop
+        # @param event [Dry::Events::Event] event details including payload
+        # @note It's an error as we can recover from it not a fatal
+        def on_connection_listener_fetch_loop_error(event)
+          error "Listener fetch loop error: #{event[:error]}"
+        end
+
+        # Logs errors that are related to the connection itself
+        # @note Karafka will attempt to reconnect, so an error not a fatal
+        # @param event [Dry::Events::Event] event details including payload
+        def on_connection_client_fetch_loop_error(event)
+          error "Client fetch loop error: #{event[:error]}"
+        end
+
+        # Logs info about crashed fetcher
+        # @note If this happens, Karafka will shutdown as it means a critical error
+        #   in one of the threads
+        # @param event [Dry::Events::Event] event details including payload
+        def on_fetcher_call_error(event)
+          fatal "Fetcher crash due to an error: #{event[:error]}"
+        end
+
+        # Logs info about processing of a certain dataset with an inline backend
+        # @param event [Dry::Events::Event] event details including payload
+        def on_backends_inline_process(event)
+          count = event[:caller].send(:params_batch).to_a.size
+          topic = event[:caller].topic.name
+          time = event[:time]
+          info "Inline processing of topic #{topic} with #{count} messages took #{time} ms"
+        end
+
+        # Logs info about system signals that Karafka received
+        # @param event [Dry::Events::Event] event details including payload
+        def on_process_notice_signal(event)
+          info "Received #{event[:signal]} system signal"
+        end
+
+        # Logs info about responder usage withing a controller flow
+        # @param event [Dry::Events::Event] event details including payload
+        def on_consumers_responders_respond_with(event)
+          calling = event[:caller].class
+          responder = calling.topic.responder
+          data = event[:data]
+          info "Responded from #{calling} using #{responder} with following data #{data}"
+        end
+
+        USED_LOG_LEVELS.each do |log_level|
+          define_method log_level do |*args|
+            Karafka.logger.send(log_level, *args)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/karafka/instrumentation/logger.rb

@@ -0,0 +1,55 @@
+# frozen_string_literal: true
+
+module Karafka
+  module Instrumentation
+    # Default logger for Event Delegator
+    # @note It uses ::Logger features - providing basic logging
+    class Logger < ::Logger
+      include Singleton
+
+      # Map containing information about log level for given environment
+      ENV_MAP = {
+        'production' => ::Logger::ERROR,
+        'test' => ::Logger::ERROR,
+        'development' => ::Logger::INFO,
+        'debug' => ::Logger::DEBUG,
+        'default' => ::Logger::INFO
+      }.freeze
+
+      # Creates a new instance of logger ensuring that it has a place to write to
+      def initialize(*_args)
+        ensure_dir_exists
+        super(target)
+        self.level = ENV_MAP[Karafka.env] || ENV_MAP['default']
+      end
+
+      private
+
+      # @return [Karafka::Helpers::MultiDelegator] multi delegator instance
+      #   to which we will be writtng logs
+      # We use this approach to log stuff to file and to the STDOUT at the same time
+      def target
+        Karafka::Helpers::MultiDelegator
+          .delegate(:write, :close)
+          .to(STDOUT, file)
+      end
+
+      # Makes sure the log directory exists
+      def ensure_dir_exists
+        dir = File.dirname(log_path)
+        FileUtils.mkdir_p(dir) unless Dir.exist?(dir)
+      end
+
+      # @return [Pathname] Path to a file to which we should log
+      def log_path
+        @log_path ||= Karafka::App.root.join("log/#{Karafka.env}.log")
+      end
+
+      # @return [File] file to which we want to write our logs
+      # @note File is being opened in append mode ('a')
+      def file
+        @file ||= File.open(log_path, 'a')
+      end
+    end
+  end
+end

data/lib/karafka/instrumentation/monitor.rb

@@ -0,0 +1,62 @@
+# frozen_string_literal: true
+
+module Karafka
+  # Namespace for all the things related with Karafka instrumentation process
+  module Instrumentation
+    # Monitor is used to hookup external monitoring services to monitor how Karafka works
+    # It provides a standardized API for checking incoming messages/enqueueing etc
+    # Since it is a pub-sub based on dry-monitor, you can use as many subscribers/loggers at the
+    # same time, which means that you might have for example file logging and newrelic at the same
+    # time
+    # @note This class acts as a singleton because we are only permitted to have single monitor
+    #   per running process (just as logger)
+    class Monitor < Dry::Monitor::Notifications
+      include Singleton
+
+      # List of events that we support in the system and to which a monitor client can hook up
+      # @note The non-error once support timestamp benchmarking
+      # @note Depending on Karafka extensions and additional engines, this might not be the
+      #   complete list of all the events. Please use the #available_events on fully loaded
+      #   Karafka system to determine all of the events you can use.
+      #   Last 4 events are from WaterDrop but for convenience we use the same monitor for the
+      #   whole karafka ecosystem
+      BASE_EVENTS = %w[
+        params.params.parse
+        params.params.parse.error
+        connection.listener.fetch_loop.error
+        connection.client.fetch_loop.error
+        connection.delegator.call
+        fetcher.call.error
+        backends.inline.process
+        process.notice_signal
+        consumers.responders.respond_with
+        async_producer.call.error
+        async_producer.call.retry
+        sync_producer.call.error
+        sync_producer.call.retry
+      ].freeze
+
+      private_constant :BASE_EVENTS
+
+      # @return [Karafka::Instrumentation::Monitor] monitor instance for system instrumentation
+      def initialize
+        super(:karafka)
+        BASE_EVENTS.each(&method(:register_event))
+      end
+
+      # Allows us to subscribe to events with a code that will be yielded upon events
+      # @param event_name_or_listener [String, Object] name of the event we want to subscribe to
+      #   or a listener if we decide to go with object listener
+      def subscribe(event_name_or_listener)
+        return super unless event_name_or_listener.is_a?(String)
+        return super if available_events.include?(event_name_or_listener)
+        raise Errors::UnregisteredMonitorEvent, event_name_or_listener
+      end
+
+      # @return [Array<String>] names of available events to which we can subscribe
+      def available_events
+        __bus__.events.keys
+      end
+    end
+  end
+end

data/lib/karafka/loader.rb

@@ -5,7 +5,6 @@ module Karafka
   module Loader
     # Order in which we want to load app files
     DIRS = %w[
-      config/initializers
       lib
       app
     ].freeze

data/lib/karafka/params/{params.rb → dsl.rb}

@@ -3,18 +3,28 @@
 module Karafka
   # Params namespace encapsulating all the logic that is directly related to params handling
   module Params
-    # Class-wrapper for hash with indifferent access with additional lazy loading feature
+    # Dsl for Karafka params. We don't provide the params class here as we want to allow users to
+    # use either hash (default) or Rails hash with indifferent access as a base for their params
+    #
+    # We do that because both of them have their own advantages and we don't want to enforce users
+    # to handle things differently if they already use any of those
+    #
     # It provides lazy loading not only until the first usage, but also allows us to skip
     # using parser until we execute our logic. That way we can operate with
     # heavy-parsing data without slowing down the whole application.
-    class Params < HashWithIndifferentAccess
-      # Kafka::FetchedMessage attributes that we want to use inside of params
-      KAFKA_MESSAGE_ATTRIBUTES = %i[
+    module Dsl
+      # Params keys that are "our" and internal. We use this list for additional backends
+      # that don't allow symbols to be transferred, to remap the interchanged params
+      # back into a valid form
+      SYSTEM_KEYS = %i[
+        parser
         value
         partition
         offset
         key
         create_time
+        receive_time
+        topic
       ].freeze
 
       # Params attributes that should be available via a method call invocation for Kafka
@@ -22,15 +32,19 @@ module Karafka
       # Kafka passes internally Kafka::FetchedMessage object and the ruby-kafka consumer
       # uses those fields via method calls, so in order to be able to pass there our params
       # objects, have to have same api.
-      PARAMS_METHOD_ATTRIBUTES = %i[
+      METHOD_ATTRIBUTES = %i[
         topic
         partition
         offset
         key
         create_time
+        receive_time
       ].freeze
 
-      class << self
+      private_constant :METHOD_ATTRIBUTES
+
+      # Class methods required by params to work
+      module ClassMethods
         # We allow building instances only via the #build method
 
         # @param message [Kafka::FetchedMessage, Hash] message that we get out of Kafka
@@ -44,38 +58,27 @@ module Karafka
         # @example Build params instance from a Kafka::FetchedMessage object
         #   Karafka::Params::Params.build(message) #=> params object
         def build(message, parser)
-          # Hash case happens inside backends that interchange data
-          if message.is_a?(Hash)
-            new(parser: parser).send(:merge!, message)
-          else
-            # This happens inside Kafka::FetchedProcessor
-            new(
-              parser: parser,
-              parsed: false,
-              received_at: Time.now
-            ).tap do |instance|
-              KAFKA_MESSAGE_ATTRIBUTES.each do |attribute|
-                instance[attribute] = message.send(attribute)
-              end
+          instance = new
+          instance[:parser] = parser
 
-              # When we get raw messages, they might have a topic, that was modified by a
-              # topic mapper. We need to "reverse" this change and map back to the non-modified
-              # format, so our internal flow is not corrupted with the mapping
-              instance[:topic] = Karafka::App.config.topic_mapper.incoming(message.topic)
-            end
+          # Non kafka fetched message can happen when we interchange data with an
+          # additional backend
+          if message.is_a?(Kafka::FetchedMessage)
+            instance[:value] = message.value
+            instance[:partition] = message.partition
+            instance[:offset] = message.offset
+            instance[:key] = message.key
+            instance[:create_time] = message.create_time
+            instance[:receive_time] = Time.now
+            # When we get raw messages, they might have a topic, that was modified by a
+            # topic mapper. We need to "reverse" this change and map back to the non-modified
+            # format, so our internal flow is not corrupted with the mapping
+            instance[:topic] = Karafka::App.config.topic_mapper.incoming(message.topic)
+          else
+            instance.send(:merge!, message)
           end
-        end
 
-        # Defines a method call accessor to a particular hash field.
-        # @note Won't work for complex key names that contain spaces, etc
-        # @param key [Symbol] name of a field that we want to retrieve with a method call
-        # @example
-        #   key_attr_reader :example
-        #   params.example #=> 'my example value'
-        def key_attr_reader(key)
-          define_method key do
-            self[key]
-          end
+          instance
         end
       end
 
@@ -85,18 +88,41 @@ module Karafka
       #   parse it again.
       def retrieve!
         return self if self[:parsed]
+        self[:parsed] = true
 
         merge!(parse(delete(:value)))
       end
 
-      PARAMS_METHOD_ATTRIBUTES.each(&method(:key_attr_reader))
+      # Includes and extends the base params klass with everything that is needed by Karafka to
+      #   fully work in any conditions.
+      # @param params_klass [Karafka::Params::Params] initialized params class that we will
+      #   use for a given Karafka process
+      def self.included(params_klass)
+        params_klass.extend(Dsl::ClassMethods)
+
+        METHOD_ATTRIBUTES.each do |attr|
+          # Defines a method call accessor to a particular hash field.
+          # @note Won't work for complex key names that contain spaces, etc
+          # @param key [Symbol] name of a field that we want to retrieve with a method call
+          # @example
+          #   key_attr_reader :example
+          #   params.example #=> 'my example value'
+          params_klass.send :define_method, attr do
+            self[attr]
+          end
+        end
+
+        params_klass.send :private, :merge!
+        params_klass.send :private, :parse
+      end
 
       private
 
       # Overwritten merge! method - it behaves differently for keys that are the same in our hash
       #  and in a other_hash - it will not replace keys that are the same in our hash
-      #  and in the other one
-      # @param other_hash [Hash, HashWithIndifferentAccess] hash that we want to merge into current
+      #  and in the other one. This protects some important Karafka params keys that cannot be
+      #  replaced with custom values from incoming Kafka message
+      # @param other_hash [Hash] hash that we want to merge into current
       # @return [Karafka::Params::Params] our parameters hash with merged values
       # @example Merge with hash without same keys
       #   new(a: 1, b: 2).merge!(c: 3) #=> { a: 1, b: 2, c: 3 }
@@ -110,18 +136,17 @@ module Karafka
         super(other_hash) { |_key, base_value, _new_value| base_value }
       end
 
-      # @param value [String] Raw data that we want to parse using controller's parser
+      # @param value [String] Raw data that we want to parse using consumer parser
       # @note If something goes wrong, it will return raw data in a hash with a message key
       # @return [Hash] parsed data or a hash with message key containing raw data if something
       #   went wrong during parsing
       def parse(value)
-        self[:parser].parse(value)
-        # We catch both of them, because for default JSON - we use JSON parser directly
+        Karafka.monitor.instrument('params.params.parse', caller: self) do
+          self[:parser].parse(value)
+        end
       rescue ::Karafka::Errors::ParserError => e
-        Karafka.monitor.notice_error(self.class, e)
+        Karafka.monitor.instrument('params.params.parse.error', caller: self, error: e)
         raise e
-      ensure
-        self[:parsed] = true
       end
     end
   end