rimless 2.9.0 → 3.1.0

data/lib/rimless/extensions/configuration_handling.rb

@@ -0,0 +1,77 @@
+# frozen_string_literal: true
+
+module Rimless
+  module Extensions
+    # The top-level configuration handling.
+    #
+    # rubocop:disable Style/ClassVars -- because we split module code
+    module ConfigurationHandling
+      extend ActiveSupport::Concern
+
+      class_methods do
+        # Retrieve the current configuration object.
+        #
+        # @return [Configuration]
+        def configuration
+          @@configuration ||= Configuration.new
+        end
+
+        # Configure the concern by providing a block which takes
+        # care of this task. Example:
+        #
+        #   FactoryBot::Instrumentation.configure do |conf|
+        #     # conf.xyz = [..]
+        #   end
+        def configure
+          yield(configuration)
+          configure_dependencies
+        end
+
+        # Reset the current configuration with the default one.
+        def reset_configuration!
+          @@configuration = Configuration.new
+        end
+
+        # Retrieve the current configured environment. You can use it like
+        # +Rails.env+ to query it. E.g. +Rimless.env.production?+.
+        #
+        # @return [ActiveSupport::StringInquirer] the environment
+        def env
+          @@env = ActiveSupport::StringInquirer.new(configuration.env.to_s) \
+            if @env.to_s != configuration.env.to_s
+          @@env
+        end
+
+        # A simple convention helper to setup Apache Kafka topic names.
+        #
+        # @param app [String] the application namespace
+        # @return [String] the Apache Kafka topic name prefix
+        def topic_prefix(app = Rimless.configuration.app_name)
+          "#{Rimless.env}.#{app}."
+        end
+
+        # Pass back the local application name. When we are loaded together
+        # with a Rails application we use the application class name. This
+        # application name is URI/GID compatible. When no local application is
+        # available, we just pass back +nil+.
+        #
+        # @return [String, nil] the Rails application name, or +nil+
+        def local_app_name
+          # Check for non-Rails integration
+          return unless defined? Rails
+          # Check if a application is defined
+          return if Rails.application.nil?
+
+          # Pass back the URI compatible application name
+          Rails.application.class.module_parent_name.underscore.dasherize
+        end
+
+        # Retrieve the current configured logger instance.
+        #
+        # @return [Logger] the logger instance
+        delegate :logger, to: :configuration
+      end
+    end
+    # rubocop:enable Style/ClassVars
+  end
+end

data/lib/rimless/extensions/consumer.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+module Rimless
+  module Extensions
+    # The top-level Apache Kafka message consumer integration.
+    module Consumer
+      extend ActiveSupport::Concern
+
+      class_methods do
+        # A simple shortcut to fetch the Karafka-wrapping consumer application.
+        #
+        # @return [Rimless::Consumer::App] the internal consumer
+        #   application class
+        def consumer
+          @consumer ||= Rimless::Consumer::App.new
+        end
+      end
+    end
+  end
+end

data/lib/rimless/extensions/dependencies.rb

@@ -0,0 +1,84 @@
+# frozen_string_literal: true
+
+module Rimless
+  module Extensions
+    # The top-level dependencies helpers.
+    module Dependencies
+      extend ActiveSupport::Concern
+
+      class_methods do
+        # (Re)configure our gem dependencies. We take care of setting up
+        # +WaterDrop+, our Apache Kafka driver and +AvroTurf+, our Confluent
+        # Schema Registry driver.
+        def configure_dependencies
+          configure_avro
+          configure_producer
+        end
+
+        # Set sensible defaults for the +AvroTurf+ gem and (re)compile the
+        # Apache Avro schema templates (ERB), so the gem can handle them
+        # properly.
+        def configure_avro
+          # No need to configure AvroTurf when no schema registry URL is
+          # available. Its fine to skip this for scenarios where the full
+          # application configuration is not available (eg. on Rails asset
+          # precompilations, etc)
+          return if Rimless.configuration.schema_registry_url.blank?
+
+          # Setup a global available Apache Avro decoder/encoder with support
+          # for the Confluent Schema Registry, but first create a helper
+          # instance
+          Rimless.avro_utils = Rimless::AvroUtils.new
+          # Compile our Avro schema templates to ready-to-consume Avro schemas
+          Rimless.avro_utils.recompile_schemas
+          # Register a global Avro messaging instance
+          Rimless.avro = AvroTurf::Messaging.new(
+            **Rimless.configuration.avro_configure.call(
+              logger: Rimless.logger,
+              namespace: Rimless.avro_utils.namespace,
+              schemas_path: Rimless.avro_utils.output_path,
+              registry_url: Rimless.configuration.schema_registry_url
+            )
+          )
+        end
+
+        # Set sensible defaults for the +WaterDrop+ gem.
+        def configure_producer
+          # Skip WaterDrop configuration when no brokers/client id is
+          # available, because it will raise. Its fine to have none available
+          # for situations like Rails asset precompilations, etc. - on runtime
+          # the settings should be available, otherwise the message producing
+          # just fails/raise.
+          return if Rimless.configuration.kafka_brokers.empty? \
+            || Rimless.configuration.client_id.blank?
+
+          # Register a global waterdrop producer instance
+          Rimless.producer = WaterDrop::Producer.new do |config|
+            # Activate message delivery and use the default logger
+            config.deliver = true
+            config.logger = Rimless.logger
+
+            # See: https://bit.ly/3OtIfeu (+config.kafka+ settings)
+
+            # An optional identifier of a Kafka consumer (in a consumer group)
+            # that is passed to a Kafka broker with every request. A logical
+            # application name to be included in Kafka logs and monitoring
+            # aggregates.
+            config.kafka[:'client.id'] = Rimless.configuration.client_id
+            # All the known brokers, at least one. The ruby-kafka driver will
+            # discover the whole cluster structure once and when issues occur
+            # to dynamically adjust scaling operations.
+            config.kafka[:'bootstrap.servers'] =
+              Rimless.configuration.kafka_brokers
+            # All brokers MUST acknowledge a new message by default
+            config.kafka[:'request.required.acks'] = -1
+
+            # Call the user-configurable block with our configuration
+            # for customizations
+            Rimless.configuration.producer_configure.call(config)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/rimless/extensions/kafka_helpers.rb

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+module Rimless
+  module Extensions
+    # The top-level Apache Kafka helpers.
+    module KafkaHelpers
+      extend ActiveSupport::Concern
+
+      class_methods do
+        # Generate a common topic name for Apache Kafka while taking care of
+        # configured prefixes.
+        #
+        # @param args [Array<Mixed>] the relative topic name
+        # @return [String] the complete topic name
+        #
+        # @example Name only
+        #   Rimless.topic(:users)
+        # @example Name with app
+        #   Rimless.topic(:users, app: 'test-api')
+        # @example Mix and match
+        #   Rimless.topic(name: 'test', app: :fancy_app)
+        # @example Full name - use as is
+        #   Rimless.topic(full_name: 'my.custom.topic.name')
+        def topic(*args)
+          opts = args.last
+          name = args.first if [String, Symbol].member?(args.first.class)
+
+          if opts.is_a?(Hash)
+            # When we got a full name, we use it as is
+            return opts[:full_name] if opts.key? :full_name
+
+            name = opts[:name] if opts.key?(:name)
+            app = opts[:app] if opts.key?(:app)
+          end
+
+          name ||= nil
+          app ||= Rimless.configuration.app_name
+
+          raise ArgumentError, 'No name given' if name.nil?
+
+          "#{Rimless.topic_prefix(app)}#{name}".tr('_', '-')
+        end
+      end
+    end
+  end
+end

data/lib/rimless/extensions/producer.rb

@@ -0,0 +1,103 @@
+# frozen_string_literal: true
+
+module Rimless
+  module Extensions
+    # The top-level Apache Kafka message producer integration.
+    module Producer
+      extend ActiveSupport::Concern
+
+      class_methods do
+        # A shared +WaterDrop::Producer+ instance
+        mattr_accessor :producer
+
+        # Send a single message to Apache Kafka. The data is encoded according
+        # to the given Apache Avro schema. The destination Kafka topic may be a
+        # relative name, or a hash which is passed to the +.topic+ method to
+        # manipulate the application details. The message is sent is a
+        # synchronous, blocking way.
+        #
+        # @param data [Hash{Symbol => Mixed}] the raw data, unencoded
+        # @param schema [String, Symbol] the Apache Avro schema to use
+        # @param topic [String, Symbol, Hash{Symbol => Mixed}] the destination
+        #   Apache Kafka topic
+        # @param args [Hash{Symbol => Mixed}] additional parameters,
+        #   see: https://bit.ly/4tHjcVg
+        def sync_message(data:, schema:, topic:, **args)
+          encoded = Rimless.encode(data, schema: schema)
+          sync_raw_message(data: encoded, topic: topic, **args)
+        end
+        alias_method :message, :sync_message
+
+        # Send a single message to Apache Kafka. The data is encoded according
+        # to the given Apache Avro schema. The destination Kafka topic may be a
+        # relative name, or a hash which is passed to the +.topic+ method to
+        # manipulate the application details. The message is sent is an
+        # asynchronous, non-blocking way.
+        #
+        # @param data [Hash{Symbol => Mixed}] the raw data, unencoded
+        # @param schema [String, Symbol] the Apache Avro schema to use
+        # @param topic [String, Symbol, Hash{Symbol => Mixed}] the destination
+        #   Apache Kafka topic
+        # @param args [Hash{Symbol => Mixed}] additional parameters,
+        #   see: https://bit.ly/4tHjcVg
+        def async_message(data:, schema:, topic:, **args)
+          encoded = Rimless.encode(data, schema: schema)
+          async_raw_message(data: encoded, topic: topic, **args)
+        end
+
+        # Send a single message to Apache Kafka. The data is not transformed, so
+        # you need to encode it yourself before you pass it in. The destination
+        # Kafka topic may be a relative name, or a hash which is passed to the
+        # +.topic+ method to manipulate the application details. The message is
+        # sent is a synchronous, blocking way.
+        #
+        # @param data [Hash{Symbol => Mixed}] the raw data, unencoded
+        # @param topic [String, Symbol, Hash{Symbol => Mixed}] the destination
+        #   Apache Kafka topic
+        # @param headers [Hash{String => String, Array<String>}, nil] the
+        #   message headers to send
+        # @param args [Hash{Symbol => Mixed}] additional parameters,
+        #   see: https://bit.ly/4tHjcVg
+        def sync_raw_message(data:, topic:, headers: nil, **args)
+          args = args.merge(topic: topic(topic), payload: data)
+
+          # A compatibility helper for headers, as WaterDrop is now more strict
+          if headers.present?
+            args[:headers] = headers
+            args[:headers].deep_stringify_keys!.deep_transform_values!(&:to_s) \
+              if headers.is_a? Hash
+          end
+
+          producer.produce_sync(**args)
+        end
+        alias_method :raw_message, :sync_raw_message
+
+        # Send a single message to Apache Kafka. The data is not touched, so
+        # you need to encode it yourself before you pass it in. The destination
+        # Kafka topic may be a relative name, or a hash which is passed to the
+        # +.topic+ method to manipulate the application details. The message is
+        # sent is an asynchronous, non-blocking way.
+        #
+        # @param data [Hash{Symbol => Mixed}] the raw data, unencoded
+        # @param topic [String, Symbol, Hash{Symbol => Mixed}] the destination
+        #   Apache Kafka topic
+        # @param headers [Hash{String => String, Array<String>}, nil] the
+        #   message headers to send
+        # @param args [Hash{Symbol => Mixed}] additional parameters,
+        #   see: https://bit.ly/4tHjcVg
+        def async_raw_message(data:, topic:, headers: nil, **args)
+          args = args.merge(topic: topic(topic), payload: data)
+
+          # A compatibility helper for headers, as WaterDrop is now more strict
+          if headers.present?
+            args[:headers] = headers
+            args[:headers].deep_stringify_keys!.deep_transform_values!(&:to_s) \
+              if headers.is_a? Hash
+          end
+
+          producer.produce_async(**args)
+        end
+      end
+    end
+  end
+end

data/lib/rimless/initializers/compatibility.rb

@@ -11,7 +11,6 @@ def rimless_gem_version?(gem_name, expected)
   Gem::Dependency.new('', expected.to_s).match?('', actual)
 end
 
-# Load some polyfills for ActiveSupport lower than 6.0
-require 'rimless/compatibility/karafka_1_4' \
-  if rimless_gem_version?('karafka', '~> 1.4') \
-     && rimless_gem_version?('thor', '>= 1.3')
+# Load some patches for GEM lower than VERSION
+# require 'rimless/compatibility/GEM__VERSION' \
+#   if rimless_gem_version?('GEM', '~> VERSION')

data/lib/rimless/railtie.rb

@@ -19,19 +19,19 @@ module Rimless
       # register application consumers
       Rails::CodeStatistics.register_directory('Consumers', 'app/consumers') \
         if defined?(Rails::CodeStatistics)
+
+      # Karafka tries forcefully to load its bootfile, when it detects a
+      # Rails application (via railtie). This may fail on applications
+      # which use Rimless just for message producing. So we configure a
+      # special setting for Karafka to skip its loading.
+      # See: https://bit.ly/4uuqFaI
+      ENV['KARAFKA_BOOT_FILE'] = 'false' unless Karafka.boot_file.exist?
     end
 
     # Run after all configuration is set via Rails initializers
     config.after_initialize do
       # Reconfigure our dependencies
       Rimless.configure_dependencies
-
-      # Load the Karafka application inside the Sidekiq server application
-      if defined? Sidekiq
-        Sidekiq.configure_server do
-          Rimless.consumer.initialize!
-        end
-      end
     end
 
     # Load all our Rake tasks if we're supposed to do

data/lib/rimless/rspec/helpers.rb

@@ -14,27 +14,41 @@ module Rimless
         Rimless.avro_decode(data, **)
       end
 
-      # A simple helper to fake a deserialized Apache Kafka message for
-      # consuming.
+      # A simple helper to generate Apache Kafka message doubles for consuming.
       #
       # @param payload [Hash{Symbol => Mixed}] the message payload
       # @param topic [String, Hash{Symbol => Mixed}] the actual message
       #   topic (full as string, or parts via hash)
-      # @return [OpenStruct] the fake deserialized Kafka message
-      def kafka_message(topic: nil, headers: {}, **payload)
-        OpenStruct.new(
-          topic: Rimless.topic(topic),
+      # @param metadata [Hash{Symbol => Mixed}] the message metadata
+      # @return [RSpec::Mocks::InstanceVerifyingDouble] the Kafka message double
+      #
+      # rubocop:disable Metrics/MethodLength -- because of the metadata handling
+      def kafka_message(topic: nil, headers: {}, metadata: {}, **payload)
+        metadata = {
+          topic: topic ? Rimless.topic(topic) : nil,
+          partition: 0,
+          offset: 206,
+          key: nil,
           headers: headers,
+          timestamp: Time.current,
+          received_at: Time.current,
+          **metadata
+        }
+
+        instance_double(
+          Karafka::Messages::Message,
+          deserialized?: true,
+          tombstone?: false,
           payload: payload,
-          is_control_record: false,
-          key: nil,
-          offset: 206,
-          partition: 0,
-          create_time: Time.current,
-          receive_time: Time.current,
-          deserialized: true
+          metadata: instance_double(
+            Karafka::Messages::Metadata,
+            **metadata,
+            to_h: metadata
+          ),
+          **metadata
         )
       end
+      # rubocop:enable Metrics/MethodLength
 
       # Capture all Apache Kafka messages of the given block.
       #
@@ -43,6 +57,32 @@ module Rimless
       def capture_kafka_messages(&)
         Rimless::RSpec::Matchers::HaveSentKafkaMessage.new(nil).capture(&)
       end
+
+      # An augmented helper for +karafka.consumer_for+, provided by the
+      # +karafka-testing+ gem to locate and instantiate a consumer. When the
+      # found consumer features the Rimless job bridge consumer logic, the
+      # +enqueue_job+ is replaced to not enqueue the job, but perform it
+      # inline. Otherwise the end-user consumer logic is not executed, which is
+      # clearly the user expectation.
+      #
+      # @param topic [String] the full topic name, use +Rimless.topic+ if
+      #   needed
+      # @return [Karafka::BaseConsumer] the found consumer
+      def kafka_consumer_for(topic)
+        # The +karafka+ helper is provided by the +karafka-testing+ gem
+        karafka.consumer_for(topic).tap do |consumer|
+          # When we're not dealing with a regular Rimless job bridge consumer,
+          # we skip further processing
+          next unless consumer.respond_to? :enqueue_job
+
+          # Otherwise rig the job bridging and run the wrapped consumer instead
+          allow(consumer).to receive(:enqueue_job) do |message|
+            Rimless.configuration.consumer_job_class.perform_now(
+              **consumer.message_to_job_args(message)
+            )
+          end
+        end
+      end
     end
   end
 end

data/lib/rimless/rspec/matchers.rb

@@ -218,19 +218,22 @@ module Rimless
         # Setup the +WaterDrop+ spies and record each sent message.
         # because of the message decoding
         def listen_to_messages
-          decode = proc do |encoded|
-            { encoded_data: encoded, data: Rimless.avro.decode(encoded) }
-          end
-
-          allow(WaterDrop::SyncProducer).to receive(:call) do |data, **args|
-            @messages << { args: args, type: :sync }.merge(decode[data])
-            nil
+          handle_message = proc do |type|
+            proc do |payload:, **args|
+              @messages << {
+                type:,
+                args:,
+                encoded_data: payload,
+                data: Rimless.avro.decode(payload)
+              }
+              nil
+            end
           end
 
-          allow(WaterDrop::AsyncProducer).to receive(:call) do |data, **args|
-            @messages << { args: args, type: :async }.merge(decode[data])
-            nil
-          end
+          allow(Rimless.producer).to \
+            receive(:produce_sync, &handle_message[:sync])
+          allow(Rimless.producer).to \
+            receive(:produce_async, &handle_message[:async])
         end
 
         # Serve the RSpec API and return the positive failure message.

data/lib/rimless/rspec.rb

@@ -5,17 +5,8 @@ require 'webmock/rspec'
 require 'rimless'
 require 'rimless/rspec/helpers'
 require 'rimless/rspec/matchers'
-require 'karafka/testing/rspec/helpers'
-
-# This fake schema registry server uses Sinatra but the gem does not include
-# this dependency as runtime, just as development. Therefore we added it.
 require 'avro_turf/test/fake_confluent_schema_registry_server'
-
-# Add a monkey patch to add proper Sinatra 4.x support
-class FakeConfluentSchemaRegistryServer
-  # Allow any host name on tests
-  set :host_authorization, { permitted_hosts: [] }
-end
+require 'karafka/testing/rspec/helpers'
 
 # RSpec 1.x and 2.x compatibility
 #
@@ -26,7 +17,12 @@ raise 'No RSPEC_CONFIGURER is defined, webmock is missing?' \
 RSPEC_CONFIGURER.configure do |config|
   config.include Rimless::RSpec::Helpers
   config.include Rimless::RSpec::Matchers
-  config.include Karafka::Testing::RSpec::Helpers
+
+  # Load the Karafka testing helpers when we're running in an actual end-user
+  # application, not within our own test suite as we do not provide a
+  # `karafka.rb` boot entry
+  config.include Karafka::Testing::RSpec::Helpers \
+    if Karafka.boot_file.exist?
 
   # Set the custom +consumer+ type for consumer spec files
   config.define_derived_metadata(file_path: %r{/spec/consumers/}) do |meta|
@@ -53,31 +49,19 @@ RSPEC_CONFIGURER.configure do |config|
   # the help of the faked (inlined) Schema Registry server. This allows us to
   # perform the actual Apache Avro message encoding/decoding without the need
   # to have a Schema Registry up and running.
-  config.before(:each) do |example|
-    # Get the Excon connection from the AvroTurf instance
-    connection = Rimless.avro.instance_variable_get(:@registry)
-                        .instance_variable_get(:@upstream)
-                        .instance_variable_get(:@connection)
-                        .instance_variable_get(:@data)
-    # Enable WebMock on the already instantiated
-    # Confluent Schema Registry Excon connection
-    connection[:mock] = true
-    # Grab all Confluent Schema Registry requests and send
+  config.before(:each) do
+    # Intercept all Confluent Schema Registry requests and send
     # them to the faked (inlined) Schema Registry
-    stub_request(:any, %r{^http://#{connection[:hostname]}})
+    stub_request(:any, /^#{Rimless.configuration.schema_registry_url}/)
       .to_rack(FakeConfluentSchemaRegistryServer)
     # Clear any cached data
     FakeConfluentSchemaRegistryServer.clear
 
     # Do not interact with Apache Kafka itself on tests
-    allow(WaterDrop::AsyncProducer).to receive(:call)
-    allow(WaterDrop::SyncProducer).to receive(:call)
+    allow(Rimless.producer).to receive(:produce_sync)
+    allow(Rimless.producer).to receive(:produce_async)
 
     # Reconfigure the Rimless AvroTurf instance
-    Rimless.configure_avro_turf
-
-    # When the example type is a Kafka consumer, we must initialize
-    # the Karafka framework first.
-    Rimless.consumer.initialize! if example.metadata[:type] == :consumer
+    Rimless.configure_avro
   end
 end

data/lib/rimless/tasks/consumer.rake

@@ -13,17 +13,29 @@ namespace :rimless do
   task routes: :environment do
     require 'rimless'
 
-    Rimless.consumer.consumer_groups.each do |consumer_group|
+    Rimless.consumer.routes.each do |consumer_group|
       consumer_group.topics.each do |topic|
         name = topic.name.split('.')[1..].join('.')
 
-        puts "#    Topic: #{name}"
-        puts "# Consumer: #{topic.consumer}"
+        consumer = topic.consumer
+        consumer = consumer.consumer.constantize \
+          if consumer.new.is_a? Rimless::Consumer::JobBridge
 
-        base = topic.consumer.superclass.new(topic).methods
-        events = topic.consumer.new(topic).methods - base
+        base_methods = consumer.superclass.instance_methods(false)
+        event_methods = (consumer.instance_methods(false) - base_methods).sort
 
-        puts "#   Events: #{events.join(', ')}"
+        event_methods = if event_methods.count > 3
+                          event_methods.join("\n##{' ' * 20}")
+                        else
+                          event_methods.join(', ')
+                        end
+
+        puts <<~INFO
+          # Topic (canonical): #{name}
+          # Topic (full name): #{topic.name}
+          #          Consumer: #{consumer}
+          #            Events: #{event_methods}
+        INFO
         puts
       end
     end

data/lib/rimless/tasks/templates/application_consumer.rb

@@ -2,5 +2,5 @@
 
 # The overall shared base consumer for Apache Kafka messages. Just write your
 # own specific consumer and inherit this one to share logic.
-class ApplicationConsumer < Rimless::BaseConsumer
+class ApplicationConsumer < Rimless::Consumer::Base
 end

data/lib/rimless/tasks/templates/custom_consumer.rb

@@ -7,6 +7,6 @@ class CustomConsumer < ApplicationConsumer
   # Handle +custom_event+ event messages.
   def custom_event(property1:, property2: nil)
     # Do whatever you need to do
-    [property1, property2]
+    Rails.logger.debug([property1, property2])
   end
 end

data/lib/rimless/tasks/templates/custom_consumer_spec.rb

@@ -4,11 +4,11 @@ require 'rails_helper'
 
 RSpec.describe CustomConsumer do
   let(:topic) { Rimless.topic(app: :your_app, name: :your_topic) }
-  let(:instance) { karafka_consumer_for(topic) }
+  let(:instance) { kafka_consumer_for(topic) }
   let(:action) { instance.consume }
-  let(:params) { kafka_message(topic: topic, **payload) }
+  let(:message) { kafka_message(topic: topic, **payload) }
 
-  before { allow(instance).to receive(:params).and_return(params) }
+  before { allow(instance).to receive(:messages).and_return([message]) }
 
   context 'with custom_event message' do
     let(:payload) do
@@ -16,7 +16,8 @@ RSpec.describe CustomConsumer do
     end
 
     it 'returns the payload properties' do
-      expect(action).to eql(['test', nil])
+      expect(Rails.logger).to receive(:debug).with(['test', nil]).once
+      action
     end
   end
 end

data/lib/rimless/tasks/templates/karafka.rb

@@ -5,16 +5,17 @@ require 'rimless'
 # Setup the topic-consumer routing table and boot the consumer application
 Rimless.consumer.topics(
   { app: :your_app, name: :your_topic } => CustomConsumer
-).boot!
+)
 
 # Configure Karafka/ruby-kafka settings
 # Rimless.consumer.configure do |config|
-#   # See https://github.com/karafka/karafka/wiki/Configuration
-#   # config.kafka.start_from_beginning = false
+#   # See: https://bit.ly/3MAF6Jk (+config.*+ root level Karafka settings)
+#   # See: https://bit.ly/3OtIfeu (+config.kafka+ settings)
+#   # config.kafka[:'initial_offset'] = 'latest'
 # end
 
 # We want a less verbose logging on development
 # Rimless.logger.level = Logger::INFO if Rails.env.development?
 
-# Use a different Sidekiq queue for the consumer jobs
+# Use a different ActiveJob queue for the consumer jobs
 # Rimless.configuration.consumer_job_queue = :messages