karafka 2.5.5 → 2.5.7

data/lib/karafka/routing/builder.rb

@@ -60,14 +60,14 @@ module Karafka
             # Validate consumer group settings
             Contracts::ConsumerGroup.new.validate!(
               consumer_group.to_h,
-              scope: ['routes', consumer_group.name]
+              scope: ["routes", consumer_group.name]
             )
 
             # and then its topics settings
             consumer_group.topics.each do |topic|
               Contracts::Topic.new.validate!(
                 topic.to_h,
-                scope: ['routes', consumer_group.name, topic.name]
+                scope: ["routes", consumer_group.name, topic.name]
               )
             end
 
@@ -78,7 +78,7 @@ module Karafka
       end
 
       # Clear out the drawn routes.
-      alias array_clear clear
+      alias_method :array_clear, :clear
       private :array_clear
 
       # Clear routes and draw them again with the given block. Helpful for testing purposes.

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

@@ -8,8 +8,8 @@ module Karafka
       class ConsumerGroup < Karafka::Contracts::Base
         configure do |config|
           config.error_messages = YAML.safe_load_file(
-            File.join(Karafka.gem_root, 'config', 'locales', 'errors.yml')
-          ).fetch('en').fetch('validations').fetch('routing').fetch('consumer_group')
+            File.join(Karafka.gem_root, "config", "locales", "errors.yml")
+          ).fetch("en").fetch("validations").fetch("routing").fetch("consumer_group")
         end
 
         required(:id) { |val| val.is_a?(String) && Karafka::Contracts::TOPIC_REGEXP.match?(val) }
@@ -49,18 +49,18 @@ module Karafka
           names = data.fetch(:topics).map { |topic| topic[:name] }
           names_hash = names.each_with_object({}) { |n, h| h[n] = true }
           error_occured = false
-          namespace_chars = ['.', '_'].freeze
+          namespace_chars = [".", "_"].freeze
           names.each do |n|
             # Skip topic names that are not namespaced
             next unless n.chars.find { |c| namespace_chars.include?(c) }
 
-            if n.chars.include?('.')
+            if n.chars.include?(".")
               # Check underscore styled topic
-              underscored_topic = n.tr('.', '_')
+              underscored_topic = n.tr(".", "_")
               error_occured = names_hash[underscored_topic] ? true : false
             else
               # Check dot styled topic
-              dot_topic = n.tr('_', '.')
+              dot_topic = n.tr("_", ".")
               error_occured = names_hash[dot_topic] ? true : false
             end
           end

data/lib/karafka/routing/contracts/routing.rb

@@ -7,8 +7,8 @@ module Karafka
       class Routing < Karafka::Contracts::Base
         configure do |config|
           config.error_messages = YAML.safe_load_file(
-            File.join(Karafka.gem_root, 'config', 'locales', 'errors.yml')
-          ).fetch('en').fetch('validations').fetch('routing')
+            File.join(Karafka.gem_root, "config", "locales", "errors.yml")
+          ).fetch("en").fetch("validations").fetch("routing")
         end
 
         # Ensures, that when declarative topics strict requirement is on, all topics have

data/lib/karafka/routing/contracts/topic.rb

@@ -7,8 +7,8 @@ module Karafka
       class Topic < Karafka::Contracts::Base
         configure do |config|
           config.error_messages = YAML.safe_load_file(
-            File.join(Karafka.gem_root, 'config', 'locales', 'errors.yml')
-          ).fetch('en').fetch('validations').fetch('routing').fetch('topic')
+            File.join(Karafka.gem_root, "config", "locales", "errors.yml")
+          ).fetch("en").fetch("validations").fetch("routing").fetch("topic")
         end
 
         required(:deserializers) { |val| !val.nil? }
@@ -59,7 +59,7 @@ module Karafka
 
           kafka = data.fetch(:kafka)
 
-          next if kafka.key?(:'bootstrap.servers')
+          next if kafka.key?(:"bootstrap.servers")
 
           [[%w[kafka bootstrap.servers], :missing]]
         end
@@ -69,7 +69,7 @@ module Karafka
           next unless Karafka::App.config.strict_topics_namespacing
 
           value = data.fetch(:name)
-          namespace_chars = ['.', '_'].freeze
+          namespace_chars = [".", "_"].freeze
           namespacing_chars_count = value.chars.find_all do |c|
             namespace_chars.include?(c)
           end.uniq.size

data/lib/karafka/routing/features/active_job/contracts/topic.rb

@@ -11,15 +11,15 @@ module Karafka
           class Topic < Karafka::Contracts::Base
             configure do |config|
               config.error_messages = YAML.safe_load_file(
-                File.join(Karafka.gem_root, 'config', 'locales', 'errors.yml')
-              ).fetch('en').fetch('validations').fetch('routing').fetch('topic')
+                File.join(Karafka.gem_root, "config", "locales", "errors.yml")
+              ).fetch("en").fetch("validations").fetch("routing").fetch("topic")
             end
 
             virtual do |data, errors|
               next unless errors.empty?
               next unless data[:active_job][:active]
               # One should not define active job jobs without ActiveJob being available for usage
-              next if Object.const_defined?('ActiveJob::Base')
+              next if Object.const_defined?("ActiveJob::Base")
 
               [[%i[consumer], :active_job_missing]]
             end

data/lib/karafka/routing/features/base/expander.rb

@@ -37,19 +37,19 @@ module Karafka
                 result = super(&block)
 
                 each do |consumer_group|
-                  if scope::Contracts.const_defined?('ConsumerGroup', false)
+                  if scope::Contracts.const_defined?("ConsumerGroup", false)
                     scope::Contracts::ConsumerGroup.new.validate!(
                       consumer_group.to_h,
-                      scope: ['routes', consumer_group.name]
+                      scope: ["routes", consumer_group.name]
                     )
                   end
 
-                  next unless scope::Contracts.const_defined?('Topic', false)
+                  next unless scope::Contracts.const_defined?("Topic", false)
 
                   consumer_group.topics.each do |topic|
                     scope::Contracts::Topic.new.validate!(
                       topic.to_h,
-                      scope: ['routes', consumer_group.name, topic.name]
+                      scope: ["routes", consumer_group.name, topic.name]
                     )
                   end
                 end

data/lib/karafka/routing/features/base.rb

@@ -13,35 +13,35 @@ module Karafka
         class << self
           # Extends topic and builder with given feature API
           def activate
-            if const_defined?('Topic', false)
+            if const_defined?("Topic", false)
               Topic.prepend(self::Topic)
             end
 
-            if const_defined?('Topics', false)
+            if const_defined?("Topics", false)
               Topics.prepend(self::Topics)
             end
 
-            if const_defined?('ConsumerGroup', false)
+            if const_defined?("ConsumerGroup", false)
               ConsumerGroup.prepend(self::ConsumerGroup)
             end
 
-            if const_defined?('Proxy', false)
+            if const_defined?("Proxy", false)
               Proxy.prepend(self::Proxy)
             end
 
-            if const_defined?('Builder', false)
+            if const_defined?("Builder", false)
               Builder.prepend(self::Builder)
             end
 
-            if const_defined?('Contracts', false)
+            if const_defined?("Contracts", false)
               Builder.prepend(Base::Expander.new(self))
             end
 
-            if const_defined?('SubscriptionGroup', false)
+            if const_defined?("SubscriptionGroup", false)
               SubscriptionGroup.prepend(self::SubscriptionGroup)
             end
 
-            if const_defined?('SubscriptionGroupsBuilder', false)
+            if const_defined?("SubscriptionGroupsBuilder", false)
               SubscriptionGroupsBuilder.prepend(self::SubscriptionGroupsBuilder)
             end
           end

data/lib/karafka/routing/features/dead_letter_queue/contracts/topic.rb

@@ -10,8 +10,8 @@ module Karafka
           class Topic < Karafka::Contracts::Base
             configure do |config|
               config.error_messages = YAML.safe_load_file(
-                File.join(Karafka.gem_root, 'config', 'locales', 'errors.yml')
-              ).fetch('en').fetch('validations').fetch('routing').fetch('topic')
+                File.join(Karafka.gem_root, "config", "locales", "errors.yml")
+              ).fetch("en").fetch("validations").fetch("routing").fetch("topic")
             end
 
             nested :dead_letter_queue do

data/lib/karafka/routing/features/declaratives/contracts/topic.rb

@@ -10,8 +10,8 @@ module Karafka
           class Topic < Karafka::Contracts::Base
             configure do |config|
               config.error_messages = YAML.safe_load_file(
-                File.join(Karafka.gem_root, 'config', 'locales', 'errors.yml')
-              ).fetch('en').fetch('validations').fetch('routing').fetch('topic')
+                File.join(Karafka.gem_root, "config", "locales", "errors.yml")
+              ).fetch("en").fetch("validations").fetch("routing").fetch("topic")
             end
 
             nested :declaratives do

data/lib/karafka/routing/features/deserializers/contracts/topic.rb

@@ -10,8 +10,8 @@ module Karafka
           class Topic < Karafka::Contracts::Base
             configure do |config|
               config.error_messages = YAML.safe_load_file(
-                File.join(Karafka.gem_root, 'config', 'locales', 'errors.yml')
-              ).fetch('en').fetch('validations').fetch('routing').fetch('topic')
+                File.join(Karafka.gem_root, "config", "locales", "errors.yml")
+              ).fetch("en").fetch("validations").fetch("routing").fetch("topic")
             end
 
             nested :deserializers do

data/lib/karafka/routing/features/eofed/contracts/topic.rb

@@ -10,8 +10,8 @@ module Karafka
           class Topic < Karafka::Contracts::Base
             configure do |config|
               config.error_messages = YAML.safe_load_file(
-                File.join(Karafka.gem_root, 'config', 'locales', 'errors.yml')
-              ).fetch('en').fetch('validations').fetch('routing').fetch('topic')
+                File.join(Karafka.gem_root, "config", "locales", "errors.yml")
+              ).fetch("en").fetch("validations").fetch("routing").fetch("topic")
             end
 
             nested :eofed do
@@ -25,7 +25,7 @@ module Karafka
 
               next unless eofed[:active]
 
-              next if data[:kafka][:'enable.partition.eof']
+              next if data[:kafka][:"enable.partition.eof"]
 
               [[%i[eofed kafka], :enable]]
             end

data/lib/karafka/routing/features/inline_insights/contracts/topic.rb

@@ -10,8 +10,8 @@ module Karafka
           class Topic < Karafka::Contracts::Base
             configure do |config|
               config.error_messages = YAML.safe_load_file(
-                File.join(Karafka.gem_root, 'config', 'locales', 'errors.yml')
-              ).fetch('en').fetch('validations').fetch('routing').fetch('topic')
+                File.join(Karafka.gem_root, "config", "locales", "errors.yml")
+              ).fetch("en").fetch("validations").fetch("routing").fetch("topic")
             end
 
             nested :inline_insights do

data/lib/karafka/routing/features/inline_insights.rb

@@ -12,17 +12,17 @@ module Karafka
           #
           # @param _config [Karafka::Core::Configurable::Node] app config
           def post_setup(_config)
-            Karafka::App.monitor.subscribe('app.running') do
+            Karafka::App.monitor.subscribe("app.running") do
               # Do not activate tracking of statistics if none of our active topics uses it
               # This prevents us from tracking metrics when user just runs a subset of topics
               # in a given process and none of those actually utilizes this feature
               next unless Karafka::App
-                          .subscription_groups
-                          .values
-                          .flat_map(&:itself)
-                          .flat_map(&:topics)
-                          .flat_map(&:to_a)
-                          .any?(&:inline_insights?)
+                .subscription_groups
+                .values
+                .flat_map(&:itself)
+                .flat_map(&:topics)
+                .flat_map(&:to_a)
+                .any?(&:inline_insights?)
 
               # Initialize the tracker prior to becoming multi-threaded
               Karafka::Processing::InlineInsights::Tracker.instance

data/lib/karafka/routing/features/manual_offset_management/contracts/topic.rb

@@ -10,8 +10,8 @@ module Karafka
           class Topic < Karafka::Contracts::Base
             configure do |config|
               config.error_messages = YAML.safe_load_file(
-                File.join(Karafka.gem_root, 'config', 'locales', 'errors.yml')
-              ).fetch('en').fetch('validations').fetch('routing').fetch('topic')
+                File.join(Karafka.gem_root, "config", "locales", "errors.yml")
+              ).fetch("en").fetch("validations").fetch("routing").fetch("topic")
             end
 
             nested :manual_offset_management do

data/lib/karafka/routing/subscription_group.rb

@@ -58,7 +58,7 @@ module Karafka
 
       # @return [String] consumer group id
       def consumer_group_id
-        kafka[:'group.id']
+        kafka[:"group.id"]
       end
 
       # @return [Integer] max messages fetched in a single go
@@ -107,7 +107,7 @@ module Karafka
       # node identifier. This refreshes this if needed when in swarm.
       def refresh
         return unless node
-        return unless kafka.key?(:'group.instance.id')
+        return unless kafka.key?(:"group.instance.id")
 
         @kafka = build_kafka
       end
@@ -124,11 +124,11 @@ module Karafka
         inject_group_instance_id(kafka)
         inject_client_id(kafka)
 
-        kafka[:'group.id'] ||= @consumer_group.id
-        kafka[:'auto.offset.reset'] ||= @topics.first.initial_offset
+        kafka[:"group.id"] ||= @consumer_group.id
+        kafka[:"auto.offset.reset"] ||= @topics.first.initial_offset
         # Karafka manages the offsets based on the processing state, thus we do not rely on the
         # rdkafka offset auto-storing
-        kafka[:'enable.auto.offset.store'] = false
+        kafka[:"enable.auto.offset.store"] = false
         kafka.freeze
         kafka
       end
@@ -146,9 +146,9 @@ module Karafka
       def inject_client_id(kafka)
         # If client id is set directly on librdkafka level, we do nothing and just go with what
         # end user has configured
-        return if kafka.key?(:'client.id')
+        return if kafka.key?(:"client.id")
 
-        kafka[:'client.id'] = client_id
+        kafka[:"client.id"] = client_id
       end
 
       # If we use static group memberships, there can be a case, where same instance id would
@@ -161,7 +161,7 @@ module Karafka
       # affecting the instance id and causing conflicts
       # @param kafka [Hash] kafka level config
       def inject_group_instance_id(kafka)
-        group_instance_prefix = kafka.fetch(:'group.instance.id', false)
+        group_instance_prefix = kafka.fetch(:"group.instance.id", false)
 
         # If group instance id was not even configured, do nothing
         return unless group_instance_prefix
@@ -170,7 +170,7 @@ module Karafka
         # have different instances ids but they are reproducible
         components = [group_instance_prefix, node ? node.id : nil, @position]
 
-        kafka[:'group.instance.id'] = components.compact.join('_')
+        kafka[:"group.instance.id"] = components.compact.join("_")
       end
     end
   end

data/lib/karafka/runner.rb

@@ -59,12 +59,12 @@ module Karafka
       workers.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
+    rescue => e
       Karafka.monitor.instrument(
-        'error.occurred',
+        "error.occurred",
         caller: self,
         error: e,
-        type: 'runner.call.error'
+        type: "runner.call.error"
       )
       Karafka::App.stop!
       raise e

data/lib/karafka/server.rb

@@ -126,11 +126,20 @@ module Karafka
 
         raise Errors::ForcefulShutdownError
       rescue Errors::ForcefulShutdownError => e
+        active_listeners = listeners.select(&:active?)
+        alive_workers = workers.select(&:alive?)
+
+        # Collect details about subscription groups that still have jobs in processing
+        in_processing = jobs_queue ? jobs_queue.in_processing : {}
+
         Karafka.monitor.instrument(
-          'error.occurred',
+          "error.occurred",
           caller: self,
           error: e,
-          type: 'app.stopping.error'
+          active_listeners: active_listeners,
+          alive_workers: alive_workers,
+          in_processing: in_processing,
+          type: "app.stopping.error"
         )
 
         # We're done waiting, lets kill them!
@@ -144,13 +153,13 @@ module Karafka
         # indefinitely even with risk of VM crash as this is a last resort.
         Thread.new do
           listeners.each(&:shutdown)
-        rescue StandardError => e
+        rescue => e
           # If anything wrong happened during shutdown, we also want to record it
           Karafka.monitor.instrument(
-            'error.occurred',
+            "error.occurred",
             caller: self,
             error: e,
-            type: 'app.forceful_stopping.error'
+            type: "app.forceful_stopping.error"
           )
         end.join(forceful_shutdown_wait / 1_000.0)
 

data/lib/karafka/setup/attributes_map.rb

@@ -334,7 +334,7 @@ module Karafka
       ].freeze
 
       # Location of the file with rdkafka settings list
-      SOURCE = <<~SOURCE.delete("\n").gsub(/\s+/, '/')
+      SOURCE = <<~SOURCE.delete("\n").gsub(/\s+/, "/")
         https://raw.githubusercontent.com
           confluentinc/librdkafka
           v#{Rdkafka::LIBRDKAFKA_VERSION}
@@ -365,21 +365,21 @@ module Karafka
         #   options list in case it would change
         def generate
           # Not used anywhere else, hence required here
-          require 'open-uri'
+          require "open-uri"
 
           attributes = { consumer: Set.new, producer: Set.new }
 
           URI.parse(SOURCE).open.readlines.each do |line|
-            next unless line.include?('|')
+            next unless line.include?("|")
 
-            attribute, attribute_type = line.split('|').map(&:strip)
+            attribute, attribute_type = line.split("|").map(&:strip)
 
             case attribute_type
-            when 'C'
+            when "C"
               attributes[:consumer] << attribute
-            when 'P'
+            when "P"
               attributes[:producer] << attribute
-            when '*'
+            when "*"
               attributes[:consumer] << attribute
               attributes[:producer] << attribute
             else

data/lib/karafka/setup/config.rb

@@ -26,12 +26,12 @@ module Karafka
         #   terms and conditions
         setting :token, default: false
         # option entity [String] for whom we did issue the license
-        setting :entity, default: ''
+        setting :entity, default: ""
       end
 
       # option client_id [String] kafka client_id - used to uniquely identify given client instance
       #   Used only for logging.
-      setting :client_id, default: 'karafka'
+      setting :client_id, default: "karafka"
       # option logger [Instance] logger that we want to use
       setting :logger, default: Karafka::Instrumentation::Logger.new
       # option monitor [Instance] monitor that we will to use (defaults to Karafka::Monitor)
@@ -41,7 +41,7 @@ module Karafka
       setting :consumer_persistence, default: true
       # option [String] should we start with the earliest possible offset or latest
       # This will set the `auto.offset.reset` value unless present in the kafka scope
-      setting :initial_offset, default: 'earliest'
+      setting :initial_offset, default: "earliest"
       # options max_messages [Integer] how many messages do we want to fetch from Kafka in one go
       setting :max_messages, default: 100
       # option [Integer] number of milliseconds we can wait while fetching data
@@ -71,7 +71,7 @@ module Karafka
       # and/or we work with existing systems where we cannot change topics names.
       setting :strict_topics_namespacing, default: true
       # option [String] default consumer group name for implicit routing
-      setting :group_id, default: 'app'
+      setting :group_id, default: "app"
       # option [Boolean] when set to true, it will validate as part of the routing validation, that
       # all topics and DLQ topics (even not active) have the declarative topics definitions.
       # Really useful when you want to ensure that all topics in routing are managed via
@@ -115,22 +115,22 @@ module Karafka
         # option [Hash] extra changes to the default root kafka settings
         setting :kafka, default: {
           # We want to know when there is no more data not to end up with an endless loop
-          'enable.partition.eof': true,
+          "enable.partition.eof": true,
           # Do not publish statistics from admin as they are not relevant
-          'statistics.interval.ms': 0,
+          "statistics.interval.ms": 0,
           # Fetch at most 5 MBs when using admin
-          'fetch.message.max.bytes': 5 * 1_048_576,
+          "fetch.message.max.bytes": 5 * 1_048_576,
           # Do not commit offset automatically, this prevents offset tracking for operations
           # involving a consumer instance
-          'enable.auto.commit': false,
+          "enable.auto.commit": false,
           # Make sure that topic metadata lookups do not create topics accidentally
-          'allow.auto.create.topics': false,
+          "allow.auto.create.topics": false,
           # Do not store offsets automatically in admin in any way
-          'enable.auto.offset.store': false
+          "enable.auto.offset.store": false
         }
 
         # option [String] default name for the admin consumer group.
-        setting :group_id, default: 'karafka_admin'
+        setting :group_id, default: "karafka_admin"
 
         # option max_wait_time [Integer] We wait only for this amount of time before raising error
         # as we intercept this error and retry after checking that the operation was finished or

data/lib/karafka/setup/contracts/config.rb

@@ -13,8 +13,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', 'errors.yml')
-          ).fetch('en').fetch('validations').fetch('setup').fetch('config')
+            File.join(Karafka.gem_root, "config", "locales", "errors.yml")
+          ).fetch("en").fetch("validations").fetch("setup").fetch("config")
         end
 
         # Topics regexp constant reference for easier usage

data/lib/karafka/setup/defaults_injector.rb

@@ -10,18 +10,18 @@ module Karafka
       CONSUMER_KAFKA_DEFAULTS = {
         # We emit the statistics by default, so all the instrumentation and web-ui work out of
         # the box, without requiring users to take any extra actions aside from enabling.
-        'statistics.interval.ms': 5_000,
-        'client.software.name': 'karafka',
+        "statistics.interval.ms": 5_000,
+        "client.software.name": "karafka",
         # Same as librdkafka default, we inject it nonetheless to have it always available as
         # some features may use this value for computation and it is better to ensure, we do
         # always have it
-        'max.poll.interval.ms': 300_000,
-        'socket.nagle.disable': true,
-        'client.software.version': [
+        "max.poll.interval.ms": 300_000,
+        "socket.nagle.disable": true,
+        "client.software.version": [
           "v#{Karafka::VERSION}",
           "rdkafka-ruby-v#{Rdkafka::VERSION}",
           "librdkafka-v#{Rdkafka::LIBRDKAFKA_VERSION}"
-        ].join('-')
+        ].join("-")
       }.freeze
 
       # Contains settings that should not be used in production but make life easier in dev
@@ -29,12 +29,12 @@ module Karafka
         # Will create non-existing topics automatically.
         # Note that the broker needs to be configured with `auto.create.topics.enable=true`
         # While it is not recommended in prod, it simplifies work in dev
-        'allow.auto.create.topics': 'true',
+        "allow.auto.create.topics": "true",
         # We refresh the cluster state often as newly created topics in dev may not be detected
         # fast enough. Fast enough means within reasonable time to provide decent user experience
         # While it's only a one time thing for new topics, it can still be irritating to have to
         # restart the process.
-        'topic.metadata.refresh.interval.ms': 5_000
+        "topic.metadata.refresh.interval.ms": 5_000
       }.freeze
 
       # Contains settings that should not be used in production but make life easier in dev
@@ -42,9 +42,9 @@ module Karafka
       # they have to set this by themselves.
       PRODUCER_KAFKA_DEV_DEFAULTS = {
         # For all of those same reasoning as for the consumer
-        'allow.auto.create.topics': 'true',
-        'topic.metadata.refresh.interval.ms': 5_000,
-        'socket.nagle.disable': true
+        "allow.auto.create.topics": "true",
+        "topic.metadata.refresh.interval.ms": 5_000,
+        "socket.nagle.disable": true
       }.freeze
 
       private_constant(

data/lib/karafka/swarm/manager.rb

@@ -77,7 +77,7 @@ module Karafka
 
       # Checks on nodes if they are ok one after another
       def control
-        monitor.instrument('swarm.manager.control', caller: self) do
+        monitor.instrument("swarm.manager.control", caller: self) do
           @nodes.each do |node|
             statuses = @statuses[node]
 
@@ -107,7 +107,7 @@ module Karafka
         # Do not run any other checks on this node if it is during stopping but still has time
         return true unless over?(statuses[:stop], shutdown_timeout)
 
-        monitor.instrument('swarm.manager.terminating', caller: self, node: node) do
+        monitor.instrument("swarm.manager.terminating", caller: self, node: node) do
           node.terminate
           statuses[:terminate] = monotonic_now
         end
@@ -135,7 +135,7 @@ module Karafka
         else
           # A single invalid report will cause it to stop. We do not support intermediate failures
           # that would recover. Such states should be implemented in the listener.
-          monitor.instrument('swarm.manager.stopping', caller: self, node: node, status: status) do
+          monitor.instrument("swarm.manager.stopping", caller: self, node: node, status: status) do
             node.stop
             statuses[:stop] = monotonic_now
           end
@@ -157,7 +157,7 @@ module Karafka
 
         # Start the stopping procedure if the node stopped reporting frequently enough
         monitor.instrument(
-          'swarm.manager.stopping',
+          "swarm.manager.stopping",
           caller: self,
           node: node,
           status: NOT_RESPONDING_SHUTDOWN_STATUS
@@ -210,9 +210,9 @@ module Karafka
         statuses.clear
         statuses[:control] = monotonic_now
 
-        monitor.instrument('swarm.manager.before_fork', instr_args)
+        monitor.instrument("swarm.manager.before_fork", instr_args)
         node.start
-        monitor.instrument('swarm.manager.after_fork', instr_args)
+        monitor.instrument("swarm.manager.after_fork", instr_args)
 
         node
       end