karafka 2.5.5 → 2.5.7

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

@@ -143,8 +143,8 @@ module Karafka
           # are always considered immediate as they indicate, that a message with a given key
           # was already dispatched or that user decided not to dispatch and cancelled the dispatch
           # via tombstone publishing.
-          if message.headers['schedule_source_type'] == 'schedule'
-            time = message.headers['schedule_target_epoch']
+          if message.headers["schedule_source_type"] == "schedule"
+            time = message.headers["schedule_target_epoch"]
 
             # Do not track historical below today as those will be reflected in the daily buffer
             @tracker.future(message) if time >= @today.starts_at
@@ -162,8 +162,8 @@ module Karafka
           # that we've got that far in the dispatching time. This allows us (with a certain buffer)
           # to quickly reject older messages (older in sense of being scheduled for previous times)
           # instead of loading them into memory until they are expired
-          if message.headers['schedule_source_type'] == 'tombstone'
-            @max_epoch.update(message.headers['schedule_target_epoch'])
+          if message.headers["schedule_source_type"] == "tombstone"
+            @max_epoch.update(message.headers["schedule_target_epoch"])
           end
 
           # Add to buffer all tombstones and messages for the same day

data/lib/karafka/pro/scheduled_messages/contracts/config.rb

@@ -29,8 +29,8 @@ module Karafka
         class Config < Karafka::Contracts::Base
           configure do |config|
             config.error_messages = YAML.safe_load_file(
-              File.join(Karafka.gem_root, 'config', 'locales', 'pro_errors.yml')
-            ).fetch('en').fetch('validations').fetch('setup').fetch('config')
+              File.join(Karafka.gem_root, "config", "locales", "pro_errors.yml")
+            ).fetch("en").fetch("validations").fetch("setup").fetch("config")
           end
 
           nested(:scheduled_messages) do

data/lib/karafka/pro/scheduled_messages/contracts/message.rb

@@ -31,8 +31,8 @@ module Karafka
         class Message < Karafka::Contracts::Base
           configure do |config|
             config.error_messages = YAML.safe_load_file(
-              File.join(Karafka.gem_root, 'config', 'locales', 'pro_errors.yml')
-            ).fetch('en').fetch('validations').fetch('scheduled_messages_message')
+              File.join(Karafka.gem_root, "config", "locales", "pro_errors.yml")
+            ).fetch("en").fetch("validations").fetch("scheduled_messages_message")
           end
 
           # Headers we expect in each message of type "schedule" that goes to our scheduled
@@ -56,7 +56,7 @@ module Karafka
           required(:headers) do |val|
             next false unless val.is_a?(Hash)
 
-            if val['schedule_source_type'] == 'message'
+            if val["schedule_source_type"] == "message"
               (val.keys & EXPECTED_SCHEDULE_HEADERS).size >= 4
             else
               (val.keys & EXPECTED_CANCEL_HEADERS).size >= 2
@@ -70,9 +70,9 @@ module Karafka
             next unless errors.empty?
 
             # Validate epoch only for schedules
-            next unless data[:headers]['schedule_source_type'] == 'schedule'
+            next unless data[:headers]["schedule_source_type"] == "schedule"
 
-            epoch_time = data[:headers].fetch('schedule_target_epoch').to_i
+            epoch_time = data[:headers].fetch("schedule_target_epoch").to_i
 
             # We allow for small lag as those will be dispatched but we should prevent dispatching
             # in the past in general as often it is a source of errors
@@ -86,11 +86,11 @@ module Karafka
             next unless errors.empty?
 
             scheduled_topics = Karafka::App
-                               .routes
-                               .flat_map(&:topics)
-                               .flat_map(&:to_a)
-                               .select(&:scheduled_messages?)
-                               .map(&:name)
+              .routes
+              .flat_map(&:topics)
+              .flat_map(&:to_a)
+              .select(&:scheduled_messages?)
+              .map(&:name)
 
             next if scheduled_topics.include?(data[:topic].to_s)
 

data/lib/karafka/pro/scheduled_messages/daily_buffer.rb

@@ -49,12 +49,12 @@ module Karafka
         # @note Only messages for a given day should be added here.
         def <<(message)
           # Non schedule are only tombstones and cancellations
-          schedule = message.headers['schedule_source_type'] == 'schedule'
+          schedule = message.headers["schedule_source_type"] == "schedule"
 
           key = message.key
 
           if schedule
-            epoch = message.headers['schedule_target_epoch']
+            epoch = message.headers["schedule_target_epoch"]
             @accu[key] = [epoch, message]
           else
             @accu.delete(key)

data/lib/karafka/pro/scheduled_messages/deserializers/headers.rb

@@ -38,18 +38,18 @@ module Karafka
           def call(metadata)
             raw_headers = metadata.raw_headers
 
-            type = raw_headers.fetch('schedule_source_type')
+            type = raw_headers.fetch("schedule_source_type")
 
             # tombstone and cancellation events are not operable, thus we do not have to cast any
             # of the headers pieces
             return raw_headers unless WORKABLE_TYPES.include?(type)
 
             headers = raw_headers.dup
-            headers['schedule_target_epoch'] = headers['schedule_target_epoch'].to_i
+            headers["schedule_target_epoch"] = headers["schedule_target_epoch"].to_i
 
             # This attribute is optional, this is why we have to check for its existence
-            if headers.key?('schedule_target_partition')
-              headers['schedule_target_partition'] = headers['schedule_target_partition'].to_i
+            if headers.key?("schedule_target_partition")
+              headers["schedule_target_partition"] = headers["schedule_target_partition"].to_i
             end
 
             headers

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

@@ -54,10 +54,10 @@ module Karafka
         # @note It also produces needed tombstone event as well as an audit log message
         def <<(message)
           target_headers = message.raw_headers.merge(
-            'schedule_source_topic' => @topic,
-            'schedule_source_partition' => @partition.to_s,
-            'schedule_source_offset' => message.offset.to_s,
-            'schedule_source_key' => message.key
+            "schedule_source_topic" => @topic,
+            "schedule_source_partition" => @partition.to_s,
+            "schedule_source_offset" => message.offset.to_s,
+            "schedule_source_key" => message.key
           ).compact
 
           target = {
@@ -90,7 +90,7 @@ module Karafka
             # We use the state as a key, so we always have one state transition data available
             key: "#{tracker.state}_state",
             partition: @partition,
-            headers: { 'zlib' => 'true' }
+            headers: { "zlib" => "true" }
           )
         end
 

data/lib/karafka/pro/scheduled_messages/proxy.rb

@@ -84,9 +84,9 @@ module Karafka
             )
 
             headers = (message[:headers] || {}).merge(
-              'schedule_schema_version' => ScheduledMessages::SCHEMA_VERSION,
-              'schedule_target_epoch' => epoch.to_i.to_s,
-              'schedule_source_type' => 'schedule'
+              "schedule_schema_version" => ScheduledMessages::SCHEMA_VERSION,
+              "schedule_target_epoch" => epoch.to_i.to_s,
+              "schedule_source_type" => "schedule"
             )
 
             export(headers, message, :topic)
@@ -118,8 +118,8 @@ module Karafka
               key: key,
               payload: nil,
               headers: {
-                'schedule_schema_version' => ScheduledMessages::SCHEMA_VERSION,
-                'schedule_source_type' => 'cancel'
+                "schedule_schema_version" => ScheduledMessages::SCHEMA_VERSION,
+                "schedule_source_type" => "cancel"
               }
             }.merge(envelope)
 
@@ -140,9 +140,9 @@ module Karafka
               topic: message.topic,
               partition: message.partition,
               headers: message.raw_headers.merge(
-                'schedule_schema_version' => ScheduledMessages::SCHEMA_VERSION,
-                'schedule_source_type' => 'tombstone',
-                'schedule_source_offset' => message.offset.to_s
+                "schedule_schema_version" => ScheduledMessages::SCHEMA_VERSION,
+                "schedule_source_type" => "tombstone",
+                "schedule_source_offset" => message.offset.to_s
               )
             }
           end

data/lib/karafka/pro/scheduled_messages/schema_validator.rb

@@ -33,7 +33,7 @@ module Karafka
           #
           # @param message [Karafka::Messages::Message]
           def call(message)
-            message_version = message.headers['schedule_schema_version']
+            message_version = message.headers["schedule_schema_version"]
 
             return if message_version <= ScheduledMessages::SCHEMA_VERSION
 

data/lib/karafka/pro/scheduled_messages/setup/config.rb

@@ -30,7 +30,7 @@ module Karafka
           extend Karafka::Core::Configurable
 
           setting(:consumer_class, default: Consumer)
-          setting(:group_id, default: 'karafka_scheduled_messages')
+          setting(:group_id, default: "karafka_scheduled_messages")
 
           # By default we will run the scheduling every 15 seconds since we provide a minute-based
           # precision. Can be increased when having dedicated processes to run this. Lower values
@@ -52,7 +52,7 @@ module Karafka
           setting(:dispatcher_class, default: Dispatcher)
 
           # Postfix for the states topic to build the states based on the group name + postfix
-          setting(:states_postfix, default: '_states')
+          setting(:states_postfix, default: "_states")
 
           setting(:deserializers) do
             # Deserializer for schedules messages to convert epochs

data/lib/karafka/pro/scheduled_messages/state.rb

@@ -46,7 +46,7 @@ module Karafka
 
         # Initializes the state as fresh
         def initialize
-          @state = 'fresh'
+          @state = "fresh"
         end
 
         STATES.each do |state|

data/lib/karafka/pro/scheduled_messages/tracker.rb

@@ -40,7 +40,7 @@ module Karafka
           @daily = Hash.new { |h, k| h[k] = 0 }
           @started_at = Time.now.to_i
           @offsets = { low: -1, high: -1 }
-          @state = 'fresh'
+          @state = "fresh"
           @reloads = 0
         end
 
@@ -71,7 +71,7 @@ module Karafka
         #   drastically increase complexity. For given day we use the accurate counter and for
         #   future days we use estimates.
         def future(message)
-          epoch = message.headers['schedule_target_epoch']
+          epoch = message.headers["schedule_target_epoch"]
 
           @daily[epoch_to_date(epoch)] += 1
         end

data/lib/karafka/pro/scheduled_messages.rb

@@ -33,11 +33,11 @@ module Karafka
       # Version of the schema we use for envelops in scheduled messages.
       # We use it to detect any potential upgrades similar to other components of Karafka and to
       # stop processing of incompatible versions
-      SCHEMA_VERSION = '1.0.0'
+      SCHEMA_VERSION = "1.0.0"
 
       # Version of the states schema. Used to publish per partition simple aggregated metrics
       # that can be used for schedules reporting
-      STATES_SCHEMA_VERSION = '1.0.0'
+      STATES_SCHEMA_VERSION = "1.0.0"
 
       class << self
         # Runs the `Proxy.call`

data/lib/karafka/pro/swarm/liveness_listener.rb

@@ -181,7 +181,7 @@ module Karafka
 
         # @return [Integer] RSS in MB for the current process
         def rss_mb
-          RUBY_PLATFORM.include?('linux') ? rss_mb_linux : rss_mb_macos
+          RUBY_PLATFORM.include?("linux") ? rss_mb_linux : rss_mb_macos
         end
 
         # @return [Integer] RSS in MB for the current process on Linux
@@ -189,7 +189,7 @@ module Karafka
           kb_rss = 0
 
           File.readlines("/proc/#{node.pid}/status").each do |line|
-            next unless line.start_with?('VmRSS:')
+            next unless line.start_with?("VmRSS:")
 
             kb_rss = line.split[1].to_i
             break

data/lib/karafka/process.rb

@@ -98,7 +98,7 @@ module Karafka
     # Informs monitoring about trapped signal
     # @param signal [Symbol] signal type that we received
     def notice_signal(signal)
-      Karafka.monitor.instrument('process.notice_signal', caller: self, signal: signal)
+      Karafka.monitor.instrument("process.notice_signal", caller: self, signal: signal)
     end
   end
 end

data/lib/karafka/processing/coordinator.rb

@@ -100,7 +100,7 @@ module Karafka
 
           # This should never happen. If it does, something is heavily out of sync. Please reach
           # out to us if you encounter this
-          raise Karafka::Errors::InvalidCoordinatorStateError, 'Was zero before decrementation'
+          raise Karafka::Errors::InvalidCoordinatorStateError, "Was zero before decrementation"
         end
       end
 

data/lib/karafka/processing/inline_insights/consumer.rb

@@ -33,10 +33,10 @@ module Karafka
           !insights.empty?
         end
 
-        alias statistics insights
-        alias statistics? insights?
-        alias inline_insights insights
-        alias inline_insights? insights?
+        alias_method :statistics, :insights
+        alias_method :statistics?, :insights?
+        alias_method :inline_insights, :insights
+        alias_method :inline_insights?, :insights?
       end
     end
   end

data/lib/karafka/processing/inline_insights/tracker.rb

@@ -68,8 +68,8 @@ module Karafka
         # @param statistics [Hash] librdkafka enriched statistics
         def add(consumer_group_id, statistics)
           @mutex.synchronize do
-            statistics.fetch('topics', EMPTY_HASH).each do |topic_name, t_details|
-              t_details.fetch('partitions', EMPTY_HASH).each do |partition_id, p_details|
+            statistics.fetch("topics", EMPTY_HASH).each do |topic_name, t_details|
+              t_details.fetch("partitions", EMPTY_HASH).each do |partition_id, p_details|
                 next unless track?(partition_id, p_details)
 
                 key = "#{consumer_group_id}_#{topic_name}_#{partition_id}"
@@ -114,12 +114,12 @@ module Karafka
         # @param p_details [Hash] partition statistics details
         # @return [Boolean] true if we should track given partition
         def track?(partition_id, p_details)
-          return false if partition_id == '-1'
+          return false if partition_id == "-1"
 
-          fetch_state = p_details.fetch('fetch_state')
+          fetch_state = p_details.fetch("fetch_state")
 
-          return false if fetch_state == 'stopped'
-          return false if fetch_state == 'none'
+          return false if fetch_state == "stopped"
+          return false if fetch_state == "none"
 
           true
         end

data/lib/karafka/processing/jobs/base.rb

@@ -38,19 +38,21 @@ module Karafka
         # When redefined can run any code prior to the job being scheduled
         # @note This will run in the listener thread and not in the worker
         def before_schedule
-          raise NotImplementedError, 'Please implement in a subclass'
+          raise NotImplementedError, "Please implement in a subclass"
         end
 
         # When redefined can run any code that should run before executing the proper code
-        def before_call; end
+        def before_call
+        end
 
         # The main entry-point of a job
         def call
-          raise NotImplementedError, 'Please implement in a subclass'
+          raise NotImplementedError, "Please implement in a subclass"
         end
 
         # When redefined can run any code that should run after executing the proper code
-        def after_call; end
+        def after_call
+        end
 
         # @return [Boolean] is this a non-blocking job
         #

data/lib/karafka/processing/jobs_queue.rb

@@ -180,6 +180,16 @@ module Karafka
         end
       end
 
+      # Returns a snapshot of all jobs currently in processing per group.
+      # Useful for diagnostics during forceful shutdown to understand what is blocking.
+      #
+      # @return [Hash{String => Array<Jobs::Base>}] hash mapping group ids to arrays of jobs
+      def in_processing
+        @mutex.synchronize do
+          @in_processing.transform_values(&:dup).freeze
+        end
+      end
+
       private
 
       # @param group_id [String] id of the group in which jobs we're interested.

data/lib/karafka/processing/schedulers/default.rb

@@ -21,10 +21,10 @@ module Karafka
         end
 
         # Revocation, shutdown and idle jobs can also run in fifo by default
-        alias on_schedule_revocation on_schedule_consumption
-        alias on_schedule_shutdown on_schedule_consumption
-        alias on_schedule_idle on_schedule_consumption
-        alias on_schedule_eofed on_schedule_consumption
+        alias_method :on_schedule_revocation, :on_schedule_consumption
+        alias_method :on_schedule_shutdown, :on_schedule_consumption
+        alias_method :on_schedule_idle, :on_schedule_consumption
+        alias_method :on_schedule_eofed, :on_schedule_consumption
 
         # This scheduler does not have anything to manage as it is a pass through and has no state
         def on_manage

data/lib/karafka/processing/strategies/base.rb

@@ -28,32 +28,32 @@ module Karafka
 
         # What should happen before we kick in the processing
         def handle_before_consume
-          raise NotImplementedError, 'Implement in a subclass'
+          raise NotImplementedError, "Implement in a subclass"
         end
 
         # What should happen in the processing
         def handle_consume
-          raise NotImplementedError, 'Implement in a subclass'
+          raise NotImplementedError, "Implement in a subclass"
         end
 
         # Post-consumption handling
         def handle_after_consume
-          raise NotImplementedError, 'Implement in a subclass'
+          raise NotImplementedError, "Implement in a subclass"
         end
 
         # Idle run handling
         def handle_idle
-          raise NotImplementedError, 'Implement in a subclass'
+          raise NotImplementedError, "Implement in a subclass"
         end
 
         # Revocation handling
         def handle_revoked
-          raise NotImplementedError, 'Implement in a subclass'
+          raise NotImplementedError, "Implement in a subclass"
         end
 
         # Shutdown handling
         def handle_shutdown
-          raise NotImplementedError, 'Implement in a subclass'
+          raise NotImplementedError, "Implement in a subclass"
         end
       end
     end

data/lib/karafka/processing/strategies/default.rb

@@ -35,8 +35,8 @@ module Karafka
         # @note It runs in the listener loop. Should **not** be used for anything heavy or
         #   with any potential errors. Mostly for initialization of states, etc.
         def handle_initialized
-          monitor.instrument('consumer.initialize', caller: self)
-          monitor.instrument('consumer.initialized', caller: self) do
+          monitor.instrument("consumer.initialize", caller: self)
+          monitor.instrument("consumer.initialized", caller: self) do
             initialized
           end
         end
@@ -120,22 +120,22 @@ module Karafka
         # @param action [Symbol]
         # @param block [Proc]
         def handle_wrap(action, &block)
-          monitor.instrument('consumer.wrap', caller: self)
-          monitor.instrument('consumer.wrapped', caller: self) do
+          monitor.instrument("consumer.wrap", caller: self)
+          monitor.instrument("consumer.wrapped", caller: self) do
             wrap(action, &block)
           end
         end
 
         # Run the user consumption code
         def handle_consume
-          monitor.instrument('consumer.consume', caller: self)
-          monitor.instrument('consumer.consumed', caller: self) do
+          monitor.instrument("consumer.consume", caller: self)
+          monitor.instrument("consumer.consumed", caller: self) do
             consume
           end
 
           # Mark job as successful
           coordinator.success!(self)
-        rescue StandardError => e
+        rescue => e
           coordinator.failure!(self, e)
 
           # Re-raise so reported in the consumer
@@ -175,8 +175,8 @@ module Karafka
 
         # Runs the consumer `#eofed` method with reporting
         def handle_eofed
-          monitor.instrument('consumer.eof', caller: self)
-          monitor.instrument('consumer.eofed', caller: self) do
+          monitor.instrument("consumer.eof", caller: self)
+          monitor.instrument("consumer.eofed", caller: self) do
             eofed
           end
         ensure
@@ -191,8 +191,8 @@ module Karafka
 
           coordinator.revoke
 
-          monitor.instrument('consumer.revoke', caller: self)
-          monitor.instrument('consumer.revoked', caller: self) do
+          monitor.instrument("consumer.revoke", caller: self)
+          monitor.instrument("consumer.revoked", caller: self) do
             revoked
           end
         ensure
@@ -201,8 +201,8 @@ module Karafka
 
         # Runs the shutdown code
         def handle_shutdown
-          monitor.instrument('consumer.shutting_down', caller: self)
-          monitor.instrument('consumer.shutdown', caller: self) do
+          monitor.instrument("consumer.shutting_down", caller: self)
+          monitor.instrument("consumer.shutdown", caller: self) do
             shutdown
           end
         ensure

data/lib/karafka/processing/strategies/dlq.rb

@@ -118,7 +118,7 @@ module Karafka
 
           # Notify about dispatch on the events bus
           monitor.instrument(
-            'dead_letter_queue.dispatched',
+            "dead_letter_queue.dispatched",
             caller: self,
             message: skippable_message
           )

data/lib/karafka/processing/worker.rb

@@ -55,9 +55,9 @@ module Karafka
 
         if job
           job.wrap do
-            monitor.instrument('worker.process', instrument_details)
+            monitor.instrument("worker.process", instrument_details)
 
-            monitor.instrument('worker.processed', instrument_details) do
+            monitor.instrument("worker.processed", instrument_details) do
               job.before_call
 
               # If a job is marked as non blocking, we can run a tick in the job queue and if there
@@ -87,12 +87,12 @@ module Karafka
       rescue Exception => e
         # rubocop:enable Lint/RescueException
         monitor.instrument(
-          'error.occurred',
+          "error.occurred",
           caller: self,
           job: job,
           jobs_queue: @jobs_queue,
           error: e,
-          type: 'worker.process.error'
+          type: "worker.process.error"
         )
       ensure
         # job can be nil when the queue is being closed
@@ -102,7 +102,7 @@ module Karafka
         end
 
         # Always publish info, that we completed all the work despite its result
-        monitor.instrument('worker.completed', instrument_details)
+        monitor.instrument("worker.completed", instrument_details)
       end
     end
   end

data/lib/karafka/railtie.rb

@@ -12,17 +12,17 @@ end
 
 if Karafka.rails?
   # Load ActiveJob adapter
-  require 'active_job/karafka'
+  require "active_job/karafka"
 
   # Setup env if configured (may be configured later by .net, etc)
-  ENV['KARAFKA_ENV'] ||= ENV['RAILS_ENV'] if ENV.key?('RAILS_ENV')
+  ENV["KARAFKA_ENV"] ||= ENV["RAILS_ENV"] if ENV.key?("RAILS_ENV")
 
   module Karafka
     # Railtie for setting up Rails integration
     class Railtie < Rails::Railtie
       railtie_name :karafka
 
-      initializer 'karafka.active_job_integration' do
+      initializer "karafka.active_job_integration" do
         ActiveSupport.on_load(:active_job) do
           # Extend ActiveJob with some Karafka specific ActiveJob magic
           extend ::Karafka::ActiveJob::JobExtensions
@@ -32,12 +32,12 @@ if Karafka.rails?
       # This lines will make Karafka print to stdout like puma or unicorn when we run karafka
       # server + will support code reloading with each fetched loop. We do it only for karafka
       # based commands as Rails processes and console will have it enabled already
-      initializer 'karafka.configure_rails_logger' do
+      initializer "karafka.configure_rails_logger" do
         # Make Karafka uses Rails logger
         ::Karafka::App.config.logger = Rails.logger
 
         next unless Rails.env.development?
-        next unless ENV.key?('KARAFKA_CLI')
+        next unless ENV.key?("KARAFKA_CLI")
         # If we are already publishing to STDOUT, no need to add it again.
         # If added again, would print stuff twice
         next if ActiveSupport::Logger.logger_outputs_to?(Rails.logger, $stdout)
@@ -46,7 +46,7 @@ if Karafka.rails?
         # Inherit the logger level from Rails, otherwise would always run with the debug level
         stdout_logger.level = Rails.logger.level
 
-        rails71plus = Rails.gem_version >= Gem::Version.new('7.1.0')
+        rails71plus = Rails.gem_version >= Gem::Version.new("7.1.0")
 
         # Rails 7.1 replaced the broadcast module with a broadcast logger
         # While 7.1 is EOL, we keep this for users who may still use it without official support
@@ -61,20 +61,20 @@ if Karafka.rails?
         end
       end
 
-      initializer 'karafka.configure_rails_auto_load_paths' do |app|
+      initializer "karafka.configure_rails_auto_load_paths" do |app|
         # Consumers should autoload by default in the Rails app so they are visible
         app.config.autoload_paths += %w[app/consumers]
       end
 
-      initializer 'karafka.require_karafka_boot_file' do |app|
-        rails6plus = Rails.gem_version >= Gem::Version.new('6.0.0')
+      initializer "karafka.require_karafka_boot_file" do |app|
+        rails6plus = Rails.gem_version >= Gem::Version.new("6.0.0")
 
         # If the boot file location is set to "false", we should not raise an exception and we
         # should just not load karafka stuff. Setting this explicitly to false indicates, that
         # karafka is part of the supply chain but it is not a first class citizen of a given
         # system (may be just a dependency of a dependency), thus railtie should not kick in to
         # load the non-existing boot file
-        next if Karafka.boot_file.to_s == 'false'
+        next if Karafka.boot_file.to_s == "false"
 
         karafka_boot_file = Rails.root.join(Karafka.boot_file.to_s).to_s
 
@@ -96,7 +96,7 @@ if Karafka.rails?
         end
       end
 
-      initializer 'karafka.configure_worker_external_executor' do |app|
+      initializer "karafka.configure_worker_external_executor" do |app|
         app.config.after_initialize do
           app_config = Karafka::App.config