karafka 2.5.5 → 2.5.7

data/lib/karafka/instrumentation/vendors/datadog/logger_listener.rb

@@ -47,7 +47,7 @@ module Karafka
           #
           # @param event [Karafka::Core::Monitoring::Event] event details including payload
           def on_worker_process(event)
-            current_span = client.trace('karafka.consumer', service: service_name)
+            current_span = client.trace("karafka.consumer", service: service_name)
             push_tags
 
             job = event[:job]
@@ -69,7 +69,7 @@ module Karafka
 
             job = event[:job]
             time = event[:time]
-            job_type = job.class.to_s.split('::').last
+            job_type = job.class.to_s.split("::").last
             consumer = job.executor.topic.consumer
             topic = job.executor.topic.name
 
@@ -90,55 +90,60 @@ module Karafka
             client.active_span&.set_error(error)
 
             case event[:type]
-            when 'consumer.initialized.error'
+            when "consumer.initialized.error"
               error "Consumer initialized error: #{error}"
-            when 'consumer.wrap.error'
+            when "consumer.wrap.error"
               error "Consumer wrap failed due to an error: #{error}"
-            when 'consumer.consume.error'
+            when "consumer.consume.error"
               error "Consumer consuming error: #{error}"
-            when 'consumer.revoked.error'
+            when "consumer.revoked.error"
               error "Consumer on revoked failed due to an error: #{error}"
-            when 'consumer.idle.error'
+            when "consumer.idle.error"
               error "Consumer idle failed due to an error: #{error}"
-            when 'consumer.shutdown.error'
+            when "consumer.shutdown.error"
               error "Consumer on shutdown failed due to an error: #{error}"
-            when 'consumer.tick.error'
+            when "consumer.tick.error"
               error "Consumer on tick failed due to an error: #{error}"
-            when 'consumer.eofed.error'
+            when "consumer.eofed.error"
               error "Consumer on eofed failed due to an error: #{error}"
-            when 'consumer.after_consume.error'
+            when "consumer.after_consume.error"
               error "Consumer on after_consume failed due to an error: #{error}"
-            when 'worker.process.error'
+            when "worker.process.error"
               fatal "Worker processing failed due to an error: #{error}"
-            when 'connection.listener.fetch_loop.error'
+            when "connection.listener.fetch_loop.error"
               error "Listener fetch loop error: #{error}"
-            when 'swarm.supervisor.error'
+            when "swarm.supervisor.error"
               fatal "Swarm supervisor crashed due to an error: #{error}"
-            when 'runner.call.error'
+            when "runner.call.error"
               fatal "Runner crashed due to an error: #{error}"
-            when 'app.stopping.error'
-              error 'Forceful Karafka server stop'
-            when 'app.forceful_stopping.error'
+            when "app.stopping.error"
+              active_listeners = event.payload[:active_listeners]
+              alive_workers = event.payload[:alive_workers]
+
+              error "Forceful Karafka server stop with: " \
+                    "#{alive_workers.size} active workers and " \
+                    "#{active_listeners.size} active listeners"
+            when "app.forceful_stopping.error"
               error "Forceful shutdown error occurred: #{error}"
-            when 'librdkafka.error'
+            when "librdkafka.error"
               error "librdkafka internal error occurred: #{error}"
-            when 'callbacks.statistics.error'
+            when "callbacks.statistics.error"
               error "callbacks.statistics processing failed due to an error: #{error}"
-            when 'callbacks.error.error'
+            when "callbacks.error.error"
               error "callbacks.error processing failed due to an error: #{error}"
             # Those will only occur when retries in the client fail and when they did not stop
             # after back-offs
-            when 'connection.client.poll.error'
+            when "connection.client.poll.error"
               error "Data polling error occurred: #{error}"
-            when 'connection.client.rebalance_callback.error'
+            when "connection.client.rebalance_callback.error"
               error "Rebalance callback error occurred: #{error}"
-            when 'connection.client.unsubscribe.error'
+            when "connection.client.unsubscribe.error"
               error "Client unsubscribe error occurred: #{error}"
-            when 'parallel_segments.reducer.error'
+            when "parallel_segments.reducer.error"
               error "Parallel segments reducer error occurred: #{error}"
-            when 'parallel_segments.partitioner.error'
+            when "parallel_segments.partitioner.error"
               error "Parallel segments partitioner error occurred: #{error}"
-            when 'virtual_partitions.partitioner.error'
+            when "virtual_partitions.partitioner.error"
               error "Virtual partitions partitioner error occurred: #{error}"
             else
               error "#{event[:type]} error occurred: #{error}"
@@ -180,7 +185,7 @@ module Karafka
           #   the assignment race condition is irrelevant here since the same value will be
           #   assigned.
           def fetch_job_type(job_class)
-            @job_types_cache[job_class] ||= job_class.to_s.split('::').last
+            @job_types_cache[job_class] ||= job_class.to_s.split("::").last
           end
         end
       end

data/lib/karafka/instrumentation/vendors/datadog/metrics_listener.rb

@@ -22,7 +22,7 @@ module Karafka
           RdKafkaMetric = Struct.new(:type, :scope, :name, :key_location)
 
           # Namespace under which the DD metrics should be published
-          setting :namespace, default: 'karafka'
+          setting :namespace, default: "karafka"
 
           # Datadog client that we should use to publish the metrics
           setting :client
@@ -37,22 +37,22 @@ module Karafka
           # Note, that the once with `_d` come from Karafka, not rdkafka or Kafka
           setting :rd_kafka_metrics, default: [
             # Client metrics
-            RdKafkaMetric.new(:count, :root, 'messages.consumed', 'rxmsgs_d'),
-            RdKafkaMetric.new(:count, :root, 'messages.consumed.bytes', 'rxmsg_bytes'),
+            RdKafkaMetric.new(:count, :root, "messages.consumed", "rxmsgs_d"),
+            RdKafkaMetric.new(:count, :root, "messages.consumed.bytes", "rxmsg_bytes"),
 
             # Broker metrics
-            RdKafkaMetric.new(:count, :brokers, 'consume.attempts', 'txretries_d'),
-            RdKafkaMetric.new(:count, :brokers, 'consume.errors', 'txerrs_d'),
-            RdKafkaMetric.new(:count, :brokers, 'receive.errors', 'rxerrs_d'),
-            RdKafkaMetric.new(:count, :brokers, 'connection.connects', 'connects_d'),
-            RdKafkaMetric.new(:count, :brokers, 'connection.disconnects', 'disconnects_d'),
-            RdKafkaMetric.new(:gauge, :brokers, 'network.latency.avg', %w[rtt avg]),
-            RdKafkaMetric.new(:gauge, :brokers, 'network.latency.p95', %w[rtt p95]),
-            RdKafkaMetric.new(:gauge, :brokers, 'network.latency.p99', %w[rtt p99]),
+            RdKafkaMetric.new(:count, :brokers, "consume.attempts", "txretries_d"),
+            RdKafkaMetric.new(:count, :brokers, "consume.errors", "txerrs_d"),
+            RdKafkaMetric.new(:count, :brokers, "receive.errors", "rxerrs_d"),
+            RdKafkaMetric.new(:count, :brokers, "connection.connects", "connects_d"),
+            RdKafkaMetric.new(:count, :brokers, "connection.disconnects", "disconnects_d"),
+            RdKafkaMetric.new(:gauge, :brokers, "network.latency.avg", %w[rtt avg]),
+            RdKafkaMetric.new(:gauge, :brokers, "network.latency.p95", %w[rtt p95]),
+            RdKafkaMetric.new(:gauge, :brokers, "network.latency.p99", %w[rtt p99]),
 
             # Topics metrics
-            RdKafkaMetric.new(:gauge, :topics, 'consumer.lags', 'consumer_lag_stored'),
-            RdKafkaMetric.new(:gauge, :topics, 'consumer.lags_delta', 'consumer_lag_stored_d')
+            RdKafkaMetric.new(:gauge, :topics, "consumer.lags", "consumer_lag_stored"),
+            RdKafkaMetric.new(:gauge, :topics, "consumer.lags_delta", "consumer_lag_stored_d")
           ].freeze
 
           # Whether histogram metrics should be sent as distributions or histograms.
@@ -101,7 +101,7 @@ module Karafka
               tags.concat(consumer_tags(event.payload[:caller]))
             end
 
-            count('error_occurred', 1, tags: tags)
+            count("error_occurred", 1, tags: tags)
           end
 
           # Reports how many messages we've polled and how much time did we spend on it
@@ -116,8 +116,8 @@ module Karafka
             tags = ["consumer_group:#{consumer_group_id}"]
             tags.concat(default_tags)
 
-            histogram('listener.polling.time_taken', time_taken, tags: tags)
-            histogram('listener.polling.messages', messages_count, tags: tags)
+            histogram("listener.polling.time_taken", time_taken, tags: tags)
+            histogram("listener.polling.messages", messages_count, tags: tags)
           end
 
           # Here we report majority of things related to processing as we have access to the
@@ -131,13 +131,13 @@ module Karafka
             tags = consumer_tags(consumer)
             tags.concat(default_tags)
 
-            count('consumer.messages', messages.size, tags: tags)
-            count('consumer.batches', 1, tags: tags)
-            gauge('consumer.offset', metadata.last_offset, tags: tags)
-            histogram('consumer.consumed.time_taken', event[:time], tags: tags)
-            histogram('consumer.batch_size', messages.size, tags: tags)
-            histogram('consumer.processing_lag', metadata.processing_lag, tags: tags)
-            histogram('consumer.consumption_lag', metadata.consumption_lag, tags: tags)
+            count("consumer.messages", messages.size, tags: tags)
+            count("consumer.batches", 1, tags: tags)
+            gauge("consumer.offset", metadata.last_offset, tags: tags)
+            histogram("consumer.consumed.time_taken", event[:time], tags: tags)
+            histogram("consumer.batch_size", messages.size, tags: tags)
+            histogram("consumer.processing_lag", metadata.processing_lag, tags: tags)
+            histogram("consumer.consumption_lag", metadata.consumption_lag, tags: tags)
           end
 
           {
@@ -164,9 +164,9 @@ module Karafka
             jq_stats = event[:jobs_queue].statistics
 
             tags = default_tags
-            gauge('worker.total_threads', Karafka::App.config.concurrency, tags: tags)
-            histogram('worker.processing', jq_stats[:busy], tags: tags)
-            histogram('worker.enqueued_jobs', jq_stats[:enqueued], tags: tags)
+            gauge("worker.total_threads", Karafka::App.config.concurrency, tags: tags)
+            histogram("worker.processing", jq_stats[:busy], tags: tags)
+            histogram("worker.enqueued_jobs", jq_stats[:enqueued], tags: tags)
           end
 
           # We report this metric before and after processing for higher accuracy
@@ -175,7 +175,7 @@ module Karafka
           def on_worker_processed(event)
             jq_stats = event[:jobs_queue].statistics
 
-            histogram('worker.processing', jq_stats[:busy], tags: default_tags)
+            histogram("worker.processing", jq_stats[:busy], tags: default_tags)
           end
 
           private
@@ -213,7 +213,7 @@ module Karafka
             else
               raise(
                 ArgumentError,
-                'distribution_mode setting value must be either :histogram or :distribution'
+                "distribution_mode setting value must be either :histogram or :distribution"
               )
             end
           end
@@ -239,13 +239,13 @@ module Karafka
                 tags: base_tags
               )
             when :brokers
-              statistics.fetch('brokers').each_value do |broker_statistics|
+              statistics.fetch("brokers").each_value do |broker_statistics|
                 # Skip bootstrap nodes
                 # Bootstrap nodes have nodeid -1, other nodes have positive
                 # node ids
-                next if broker_statistics['nodeid'] == -1
+                next if broker_statistics["nodeid"] == -1
 
-                tags = ["broker:#{broker_statistics['nodename']}"]
+                tags = ["broker:#{broker_statistics["nodename"]}"]
                 tags.concat(base_tags)
 
                 public_send(
@@ -256,16 +256,16 @@ module Karafka
                 )
               end
             when :topics
-              statistics.fetch('topics').each do |topic_name, topic_values|
-                topic_values['partitions'].each do |partition_name, partition_statistics|
-                  next if partition_name == '-1'
+              statistics.fetch("topics").each do |topic_name, topic_values|
+                topic_values["partitions"].each do |partition_name, partition_statistics|
+                  next if partition_name == "-1"
                   # Skip until lag info is available
-                  next if partition_statistics['consumer_lag'] == -1
-                  next if partition_statistics['consumer_lag_stored'] == -1
+                  next if partition_statistics["consumer_lag"] == -1
+                  next if partition_statistics["consumer_lag_stored"] == -1
 
                   # Skip if we do not own the fetch assignment
-                  next if partition_statistics['fetch_state'] == 'stopped'
-                  next if partition_statistics['fetch_state'] == 'none'
+                  next if partition_statistics["fetch_state"] == "stopped"
+                  next if partition_statistics["fetch_state"] == "none"
 
                   tags = ["topic:#{topic_name}", "partition:#{partition_name}"]
                   tags.concat(base_tags)

data/lib/karafka/instrumentation/vendors/kubernetes/base_listener.rb

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-require 'socket'
+require "socket"
 
 module Karafka
   module Instrumentation
@@ -13,10 +13,10 @@ module Karafka
           include Karafka::Core::Helpers::Time
 
           # All good with Karafka
-          OK_CODE = '200 OK'
+          OK_CODE = "200 OK"
 
           # Some timeouts, fail
-          FAIL_CODE = '500 Internal Server Error'
+          FAIL_CODE = "500 Internal Server Error"
 
           private_constant :OK_CODE, :FAIL_CODE
 
@@ -32,7 +32,7 @@ module Karafka
 
           # @return [Boolean] true if all good, false if we should tell k8s to kill this process
           def healthy?
-            raise NotImplementedError, 'Implement in a subclass'
+            raise NotImplementedError, "Implement in a subclass"
           end
 
           private
@@ -58,7 +58,7 @@ module Karafka
           # @return [Hash] hash that will be the response body
           def status_body
             {
-              status: healthy? ? 'healthy' : 'unhealthy',
+              status: healthy? ? "healthy" : "unhealthy",
               timestamp: Time.now.to_i,
               port: @port,
               process_id: ::Process.pid

data/lib/karafka/instrumentation/vendors/kubernetes/liveness_listener.rb

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-require 'karafka/instrumentation/vendors/kubernetes/base_listener'
+require "karafka/instrumentation/vendors/kubernetes/base_listener"
 
 module Karafka
   module Instrumentation

data/lib/karafka/instrumentation/vendors/kubernetes/swarm_liveness_listener.rb

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-require 'karafka/instrumentation/vendors/kubernetes/base_listener'
+require "karafka/instrumentation/vendors/kubernetes/base_listener"
 
 module Karafka
   module Instrumentation

data/lib/karafka/licenser.rb

@@ -4,15 +4,25 @@ module Karafka
   # Checks the license presence for pro and loads pro components when needed (if any)
   class Licenser
     # Location in the gem where we store the public key
-    PUBLIC_KEY_LOCATION = File.join(Karafka.gem_root, 'certs', 'karafka-pro.pem')
+    PUBLIC_KEY_LOCATION = File.join(Karafka.gem_root, "certs", "karafka-pro.pem")
+
+    # Location of file containing expired/revoked license checksums
+    EXPIRED_CHECKSUMS_LOCATION = File.join(Karafka.gem_root, "certs", "expired.txt")
 
     private_constant :PUBLIC_KEY_LOCATION
 
     class << self
       # Tries to load the license and yields if successful
       def detect
-        # If required, do not require again
-        require('karafka-license') unless const_defined?('::Karafka::License')
+        # If license module is already fully defined, don't touch it
+        # This allows users to define their own License module for testing/custom setups
+        unless license_fully_defined?
+          # Try safe approach first (no code execution)
+          loaded = safe_load_license || fallback_require_license
+
+          # If neither method succeeded, return false
+          return false unless loaded
+        end
 
         yield
 
@@ -26,7 +36,7 @@ module Karafka
       # @param license_config [Karafka::Core::Configurable::Node] config related to the licensing
       def prepare_and_verify(license_config)
         # If license is not loaded, nothing to do
-        return unless const_defined?('::Karafka::License')
+        return unless const_defined?("::Karafka::License")
 
         prepare(license_config)
         verify(license_config)
@@ -34,6 +44,65 @@ module Karafka
 
       private
 
+      # Check if License module and required methods are already defined
+      # @return [Boolean]
+      def license_fully_defined?
+        return false unless const_defined?("::Karafka::License")
+
+        # Check if the required methods exist
+        ::Karafka::License.respond_to?(:token) &&
+          ::Karafka::License.respond_to?(:version)
+      end
+
+      # Attempt to safely load license without executing gem code
+      # @return [Boolean] true if successful, false otherwise
+      def safe_load_license
+        # First verify the gem exists and files are accessible
+        spec = Gem::Specification.find_by_name("karafka-license")
+        license_path = File.join(spec.gem_dir, "lib", "license.txt")
+        version_path = File.join(spec.gem_dir, "lib", "version.txt")
+
+        return false unless File.exist?(license_path)
+
+        # Read license data to ensure we can successfully load before removing any constants
+        license_token = File.read(license_path)
+        version_content = File.read(version_path)
+
+        # Only after confirming we have valid data, remove and replace the License constant
+        # This ensures we always use the actual license from the gem, overwriting any stale
+        # or incomplete License module that may have been defined elsewhere
+        ::Karafka.send(:remove_const, :License) if const_defined?("::Karafka::License")
+
+        ::Karafka.const_set(:License, Module.new)
+        ::Karafka::License.define_singleton_method(:token) { license_token }
+        ::Karafka::License.define_singleton_method(:version) { version_content }
+
+        true
+      rescue Gem::MissingSpecError, Errno::ENOENT
+        # Gem not found or files don't exist - don't touch existing License constant
+        false
+      end
+
+      # Fallback to traditional require if safe method fails
+      # @return [Boolean] true if successful, false otherwise
+      def fallback_require_license
+        # First check if we can actually load the gem before removing any constants
+        # Try to find the gem spec to see if it exists
+        begin
+          Gem::Specification.find_by_name("karafka-license")
+        rescue Gem::MissingSpecError
+          return false
+        end
+
+        # Gem exists, so we can safely remove and reload the License constant
+        ::Karafka.send(:remove_const, :License) if const_defined?("::Karafka::License")
+
+        require("karafka-license")
+        true
+      rescue LoadError
+        false
+      end
+
       # @param license_config [Karafka::Core::Configurable::Node] config related to the licensing
       def prepare(license_config)
         license_config.token = Karafka::License.token
@@ -45,8 +114,12 @@ module Karafka
         public_key = OpenSSL::PKey::RSA.new(File.read(PUBLIC_KEY_LOCATION))
 
         # We gsub and strip in case someone copy-pasted it as a multi line string
-        formatted_token = license_config.token.strip.delete("\n").delete(' ')
-        decoded_token = formatted_token.unpack1('m') # decode from base64
+        formatted_token = license_config.token.strip.delete("\n").delete(" ")
+
+        # Check if the license has been revoked/expired before attempting decryption
+        raise_expired_license_token(license_config) if expired?(formatted_token)
+
+        decoded_token = formatted_token.unpack1("m") # decode from base64
 
         begin
           data = public_key.public_decrypt(decoded_token)
@@ -56,7 +129,26 @@ module Karafka
 
         details = data ? JSON.parse(data) : raise_invalid_license_token(license_config)
 
-        license_config.entity = details.fetch('entity')
+        license_config.entity = details.fetch("entity")
+      end
+
+      # Checks if the license token has been expired/revoked
+      # @param formatted_token [String] formatted license token
+      # @return [Boolean] true if the license is in the expired list
+      def expired?(formatted_token)
+        token_checksum = Digest::SHA256.hexdigest(formatted_token)
+
+        expired_checksums.include?(token_checksum)
+      end
+
+      # Loads the list of expired license checksums
+      # @return [Set<String>] set of expired license checksums
+      def expired_checksums
+        File
+          .readlines(EXPIRED_CHECKSUMS_LOCATION)
+          .map(&:strip)
+          .reject { |line| line.empty? || line.start_with?("#") }
+          .to_set
       end
 
       # Raises an error with info, that used token is invalid
@@ -67,12 +159,27 @@ module Karafka
 
         raise(
           Errors::InvalidLicenseTokenError,
-          <<~MSG.tr("\n", ' ')
+          <<~MSG.tr("\n", " ")
             License key you provided is invalid.
             Please reach us at contact@karafka.io or visit https://karafka.io to obtain a valid one.
           MSG
         )
       end
+
+      # Raises an error with info, that used token has expired or been revoked
+      # @param license_config [Karafka::Core::Configurable::Node]
+      def raise_expired_license_token(license_config)
+        # We set it to false so `Karafka.pro?` method behaves as expected
+        license_config.token = false
+
+        raise(
+          Errors::ExpiredLicenseTokenError,
+          <<~MSG.tr("\n", " ")
+            License key you provided has expired or been revoked.
+            Please reach us at contact@karafka.io or visit https://karafka.io to obtain a valid one.
+          MSG
+        )
+      end
     end
   end
 end

data/lib/karafka/messages/builders/batch_metadata.rb

@@ -17,16 +17,18 @@ module Karafka
           # @note We do not set `processed_at` as this needs to be assigned when the batch is
           #   picked up for processing.
           def call(messages, topic, partition, scheduled_at)
+            last_message = messages.last
+
             Karafka::Messages::BatchMetadata.new(
               size: messages.size,
               first_offset: messages.first&.offset || -1001,
-              last_offset: messages.last&.offset || -1001,
+              last_offset: last_message&.offset || -1001,
               deserializers: topic.deserializers,
               partition: partition,
               topic: topic.name,
               # We go with the assumption that the creation of the whole batch is the last message
               # creation time
-              created_at: local_created_at(messages.last),
+              created_at: local_created_at(last_message),
               # When this batch was built and scheduled for execution
               scheduled_at: scheduled_at,
               # This needs to be set to a correct value prior to processing starting

data/lib/karafka/messages/messages.rb

@@ -96,7 +96,7 @@ module Karafka
         @messages_array
       end
 
-      alias count size
+      alias_method :count, :size
     end
   end
 end

data/lib/karafka/patches/rdkafka/bindings.rb

@@ -80,7 +80,7 @@ module Karafka
           tpl = ::Rdkafka::Consumer::TopicPartitionList.from_native_tpl(partitions_ptr).freeze
           opaque = ::Rdkafka::Config.opaques[opaque_ptr.to_i]
 
-          if RB.rd_kafka_rebalance_protocol(client_ptr) == 'COOPERATIVE'
+          if RB.rd_kafka_rebalance_protocol(client_ptr) == "COOPERATIVE"
             pr.on_cooperative_rebalance(client_ptr, code, partitions_ptr, tpl, opaque)
           else
             pr.on_eager_rebalance(client_ptr, code, partitions_ptr, tpl, opaque)
@@ -95,7 +95,7 @@ end
 # At the moment there is no API in rdkafka-ruby to do so
 Rdkafka::Bindings.send(
   :remove_const,
-  'RebalanceCallback'
+  "RebalanceCallback"
 )
 
 Rdkafka::Bindings.const_set(

data/lib/karafka/pro/active_job/job_options_contract.rb

@@ -28,8 +28,8 @@ module Karafka
       class JobOptionsContract < 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('job_options')
+            File.join(Karafka.gem_root, "config", "locales", "errors.yml")
+          ).fetch("en").fetch("validations").fetch("job_options")
         end
 
         optional(:producer) { |val| val.nil? || val.respond_to?(:call) }

data/lib/karafka/pro/cleaner/messages/messages.rb

@@ -53,6 +53,16 @@ module Karafka
               super(&)
             end
           end
+
+          # Cleans all messages in the batch
+          #
+          # @param metadata [Boolean] should we also clean metadata alongside the payload for
+          #   each message. `true` by default.
+          #
+          # @note This is a convenience method that calls `clean!` on each message in the batch.
+          def clean!(metadata: true)
+            each { |message| message.clean!(metadata: metadata) }
+          end
         end
       end
     end

data/lib/karafka/pro/cli/contracts/server.rb

@@ -30,8 +30,8 @@ module Karafka
         class Server < Karafka::Cli::Contracts::Server
           configure do |config|
             config.error_messages = YAML.safe_load_file(
-              File.join(Karafka.gem_root, 'config', 'locales', 'errors.yml')
-            ).fetch('en').fetch('validations').fetch('cli').fetch('server')
+              File.join(Karafka.gem_root, "config", "locales", "errors.yml")
+            ).fetch("en").fetch("validations").fetch("cli").fetch("server")
           end
 
           %i[
@@ -66,10 +66,10 @@ module Karafka
               next if value.empty?
 
               subscription_groups = Karafka::App
-                                    .consumer_groups
-                                    .map(&:subscription_groups)
-                                    .flatten
-                                    .map(&:name)
+                .consumer_groups
+                .map(&:subscription_groups)
+                .flatten
+                .map(&:name)
 
               next if (value - subscription_groups).empty?
 
@@ -87,12 +87,12 @@ module Karafka
               next if value.empty?
 
               topics = Karafka::App
-                       .consumer_groups
-                       .map(&:subscription_groups)
-                       .flatten
-                       .map(&:topics)
-                       .map { |gtopics| gtopics.map(&:name) }
-                       .flatten
+                .consumer_groups
+                .map(&:subscription_groups)
+                .flatten
+                .map(&:topics)
+                .map { |gtopics| gtopics.map(&:name) }
+                .flatten
 
               next if (value - topics).empty?
 

data/lib/karafka/pro/cli/parallel_segments/base.rb

@@ -47,9 +47,9 @@ module Karafka
             requested_groups = options[:groups].dup || []
 
             workable_groups = Karafka::App
-                              .routes
-                              .select(&:parallel_segments?)
-                              .group_by(&:segment_origin)
+              .routes
+              .select(&:parallel_segments?)
+              .group_by(&:segment_origin)
 
             # Use all if none provided
             return workable_groups if requested_groups.empty?
@@ -85,7 +85,7 @@ module Karafka
             consumer_groups = [segment_origin, segments.map(&:name)].flatten
 
             consumer_groups_with_topics = consumer_groups
-                                          .to_h { |name| [name, topics_names] }
+              .to_h { |name| [name, topics_names] }
 
             lags_with_offsets = Karafka::Admin.read_lags_with_offsets(
               consumer_groups_with_topics