karafka 2.5.4 → 2.5.6

data/lib/karafka/instrumentation/callbacks/statistics.rb

@@ -28,10 +28,10 @@ module Karafka
           # rdkafka does not have per-instance statistics hook, thus we need to make sure that we
           # emit only stats that are related to current producer. Otherwise we would emit all of
           # all the time.
-          return unless @client_name == statistics['name']
+          return unless @client_name == statistics["name"]
 
           monitor.instrument(
-            'statistics.emitted',
+            "statistics.emitted",
             subscription_group_id: @subscription_group_id,
             consumer_group_id: @consumer_group_id,
             statistics: @statistics_decorator.call(statistics)
@@ -39,13 +39,13 @@ module Karafka
         # We need to catch and handle any potential errors coming from the instrumentation pipeline
         # as otherwise, in case of statistics which run in the main librdkafka thread, any crash
         # will hang the whole process.
-        rescue StandardError => e
+        rescue => e
           monitor.instrument(
-            'error.occurred',
+            "error.occurred",
             caller: self,
             subscription_group_id: @subscription_group_id,
             consumer_group_id: @consumer_group_id,
-            type: 'callbacks.statistics.error',
+            type: "callbacks.statistics.error",
             error: e
           )
         end

data/lib/karafka/instrumentation/logger.rb

@@ -7,11 +7,11 @@ module Karafka
     class Logger < ::Logger
       # Map containing information about log level for given environment
       ENV_MAP = {
-        'production' => Logger::ERROR,
-        'test' => Logger::ERROR,
-        'development' => Logger::INFO,
-        'debug' => Logger::DEBUG,
-        'default' => Logger::INFO
+        "production" => Logger::ERROR,
+        "test" => Logger::ERROR,
+        "development" => Logger::INFO,
+        "debug" => Logger::DEBUG,
+        "default" => Logger::INFO
       }.freeze
 
       private_constant :ENV_MAP
@@ -21,7 +21,7 @@ module Karafka
       #   make this logger compatible with the default Ruby one
       def initialize(*_args)
         super(target)
-        self.level = ENV_MAP[Karafka.env] || ENV_MAP['default']
+        self.level = ENV_MAP[Karafka.env] || ENV_MAP["default"]
       end
 
       private
@@ -45,7 +45,7 @@ module Karafka
       def file
         FileUtils.mkdir_p(File.dirname(log_path))
 
-        @file ||= File.open(log_path, 'a')
+        @file ||= File.open(log_path, "a")
       rescue Errno::EACCES, Errno::EROFS
         nil
       end

data/lib/karafka/instrumentation/logger_listener.rb

@@ -29,7 +29,7 @@ module Karafka
         listener_id = event[:caller].id
         subscription_group = event[:subscription_group]
         consumer_group_id = subscription_group.consumer_group.id
-        topics = subscription_group.topics.select(&:active?).map(&:name).join(', ')
+        topics = subscription_group.topics.select(&:active?).map(&:name).join(", ")
         group_details = "#{consumer_group_id}/#{subscription_group.id}"
 
         info(
@@ -70,7 +70,7 @@ module Karafka
       # @param event [Karafka::Core::Monitoring::Event] event details including payload
       def on_worker_process(event)
         job = event[:job]
-        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
         partition = job.executor.partition
@@ -83,11 +83,11 @@ module Karafka
       def on_worker_processed(event)
         job = event[:job]
         time = event[:time].round(2)
-        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
         partition = job.executor.partition
-        info <<~MSG.tr("\n", ' ').strip!
+        info <<~MSG.tr("\n", " ").strip!
           [#{job.id}] #{job_type} job for #{consumer}
           on #{topic}-#{partition} finished in #{time} ms
         MSG
@@ -104,10 +104,10 @@ module Karafka
         offset = event[:offset]
         client = event[:caller]
 
-        info <<~MSG.tr("\n", ' ').strip!
+        info <<~MSG.tr("\n", " ").strip!
           [#{client.id}]
           Pausing on topic #{topic}-#{partition}
-          on #{offset ? "offset #{offset}" : 'the consecutive offset'}
+          on #{offset ? "offset #{offset}" : "the consecutive offset"}
         MSG
       end
 
@@ -119,7 +119,7 @@ module Karafka
         partition = event[:partition]
         client = event[:caller]
 
-        info <<~MSG.tr("\n", ' ').strip!
+        info <<~MSG.tr("\n", " ").strip!
           [#{client.id}] Resuming on topic #{topic}-#{partition}
         MSG
       end
@@ -134,7 +134,7 @@ module Karafka
         consumer = event[:caller]
         timeout = event[:timeout]
 
-        info <<~MSG.tr("\n", ' ').strip!
+        info <<~MSG.tr("\n", " ").strip!
           [#{consumer.id}] Retrying of #{consumer.class} after #{timeout} ms
           on topic #{topic}-#{partition} from offset #{offset}
         MSG
@@ -149,7 +149,7 @@ module Karafka
         seek_offset = event[:message].offset
         consumer = event[:caller]
 
-        info <<~MSG.tr("\n", ' ').strip!
+        info <<~MSG.tr("\n", " ").strip!
           [#{consumer.id}] Seeking from #{consumer.class}
           on topic #{topic}-#{partition} to offset #{seek_offset}
         MSG
@@ -170,13 +170,13 @@ module Karafka
         Thread.list.each do |thread|
           tid = (thread.object_id ^ ::Process.pid).to_s(36)
 
-          warn ''
+          warn ""
           warn "Thread TID-#{tid} #{thread.name}"
 
           if thread.backtrace && !thread.backtrace.empty?
             warn thread.backtrace.join("\n")
           else
-            warn '<no backtrace available>'
+            warn "<no backtrace available>"
           end
         end
       end
@@ -232,7 +232,7 @@ module Karafka
           info "#{group_prefix}: No partitions revoked"
         else
           revoked_partitions.each do |topic, partitions|
-            info "#{group_prefix}: #{topic}-[#{partitions.join(',')}] revoked"
+            info "#{group_prefix}: #{topic}-[#{partitions.join(",")}] revoked"
           end
         end
       end
@@ -250,7 +250,7 @@ module Karafka
           info "#{group_prefix}: No partitions assigned"
         else
           assigned_partitions.each do |topic, partitions|
-            info "#{group_prefix}: #{topic}-[#{partitions.join(',')}] assigned"
+            info "#{group_prefix}: #{topic}-[#{partitions.join(",")}] assigned"
           end
         end
       end
@@ -266,7 +266,7 @@ module Karafka
         dlq_topic = consumer.topic.dead_letter_queue.topic
         partition = message.partition
 
-        info <<~MSG.tr("\n", ' ').strip!
+        info <<~MSG.tr("\n", " ").strip!
           [#{consumer.id}] Dispatched message #{offset}
           from #{topic}-#{partition}
           to DLQ topic: #{dlq_topic}
@@ -284,7 +284,7 @@ module Karafka
         partition = message.partition
         offset = message.offset
 
-        info <<~MSG.tr("\n", ' ').strip!
+        info <<~MSG.tr("\n", " ").strip!
           [#{consumer.id}] Throttled and will resume
           from message #{offset}
           on #{topic}-#{partition}
@@ -300,7 +300,7 @@ module Karafka
         partition = message.partition
         offset = message.offset
 
-        info <<~MSG.tr("\n", ' ').strip!
+        info <<~MSG.tr("\n", " ").strip!
           [#{consumer.id}] Post-filtering seeking to message #{offset}
           on #{topic}-#{partition}
         MSG
@@ -330,7 +330,7 @@ module Karafka
 
       # @param event [Karafka::Core::Monitoring::Event] event details including payload
       def on_swarm_manager_control(event)
-        pids = event[:caller].nodes.map(&:pid).join(', ')
+        pids = event[:caller].nodes.map(&:pid).join(", ")
         debug "Swarm manager checking nodes: #{pids}"
       end
 
@@ -342,49 +342,49 @@ module Karafka
         error = event[:error]
         backtrace = (error.backtrace || []).join("\n")
 
-        details = [error.to_s, error_details(event)].compact.join(' ')
+        details = [error.to_s, error_details(event)].compact.join(" ")
 
         case type
-        when 'consumer.initialized.error'
+        when "consumer.initialized.error"
           error "Consumer initialized error: #{details}"
           error backtrace
-        when 'consumer.wrap.error'
+        when "consumer.wrap.error"
           error "Consumer wrap failed due to an error: #{details}"
           error backtrace
-        when 'consumer.consume.error'
+        when "consumer.consume.error"
           error "Consumer consuming error: #{details}"
           error backtrace
-        when 'consumer.revoked.error'
+        when "consumer.revoked.error"
           error "Consumer on revoked failed due to an error: #{details}"
           error backtrace
-        when 'consumer.idle.error'
+        when "consumer.idle.error"
           error "Consumer idle failed due to an error: #{details}"
           error backtrace
-        when 'consumer.shutdown.error'
+        when "consumer.shutdown.error"
           error "Consumer on shutdown failed due to an error: #{details}"
           error backtrace
-        when 'consumer.tick.error'
+        when "consumer.tick.error"
           error "Consumer on tick failed due to an error: #{details}"
           error backtrace
-        when 'consumer.eofed.error'
+        when "consumer.eofed.error"
           error "Consumer on eofed failed due to an error: #{details}"
           error backtrace
-        when 'consumer.after_consume.error'
+        when "consumer.after_consume.error"
           error "Consumer on after_consume failed due to an error: #{details}"
           error backtrace
-        when 'worker.process.error'
+        when "worker.process.error"
           fatal "Worker processing failed due to an error: #{details}"
           fatal backtrace
-        when 'connection.listener.fetch_loop.error'
+        when "connection.listener.fetch_loop.error"
           error "Listener fetch loop error: #{details}"
           error backtrace
-        when 'swarm.supervisor.error'
+        when "swarm.supervisor.error"
           fatal "Swarm supervisor crashed due to an error: #{details}"
           fatal backtrace
-        when 'runner.call.error'
+        when "runner.call.error"
           fatal "Runner crashed due to an error: #{details}"
           fatal backtrace
-        when 'app.stopping.error'
+        when "app.stopping.error"
           # Counts number of workers and listeners that were still active when forcing the
           # shutdown. Please note, that unless all listeners are closed, workers will not finalize
           # their operations as well.
@@ -393,46 +393,46 @@ module Karafka
           listeners = Server.listeners ? Server.listeners.count(&:active?) : 0
           workers = Server.workers ? Server.workers.count(&:alive?) : 0
 
-          message = <<~MSG.tr("\n", ' ').strip!
+          message = <<~MSG.tr("\n", " ").strip!
             Forceful Karafka server stop with:
             #{workers} active workers and
             #{listeners} active listeners
           MSG
 
           error message
-        when 'app.forceful_stopping.error'
+        when "app.forceful_stopping.error"
           error "Forceful shutdown error occurred: #{details}"
           error backtrace
-        when 'librdkafka.error'
+        when "librdkafka.error"
           error "librdkafka internal error occurred: #{details}"
           error backtrace
         # Those can occur when emitted statistics are consumed by the end user and the processing
         # of statistics fails. The statistics are emitted from librdkafka main loop thread and
         # any errors there crash the whole thread
-        when 'callbacks.statistics.error'
+        when "callbacks.statistics.error"
           error "callbacks.statistics processing failed due to an error: #{details}"
           error backtrace
-        when 'callbacks.error.error'
+        when "callbacks.error.error"
           error "callbacks.error processing failed due to an error: #{details}"
           error backtrace
         # 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: #{details}"
           error backtrace
-        when 'connection.client.rebalance_callback.error'
+        when "connection.client.rebalance_callback.error"
           error "Rebalance callback error occurred: #{details}"
           error backtrace
-        when 'connection.client.unsubscribe.error'
+        when "connection.client.unsubscribe.error"
           error "Client unsubscribe error occurred: #{details}"
           error backtrace
-        when 'parallel_segments.reducer.error'
+        when "parallel_segments.reducer.error"
           error "Parallel segments reducer error occurred: #{details}"
           error backtrace
-        when 'parallel_segments.partitioner.error'
+        when "parallel_segments.partitioner.error"
           error "Parallel segments partitioner error occurred: #{details}"
           error backtrace
-        when 'virtual_partitions.partitioner.error'
+        when "virtual_partitions.partitioner.error"
           error "Virtual partitions partitioner error occurred: #{details}"
           error backtrace
         # This handles any custom errors coming from places like Web-UI, etc
@@ -465,19 +465,19 @@ module Karafka
         # Collect extra info if it was a consumer related error.
         # Those come from user code
         details = case caller_ref
-                  when Karafka::BaseConsumer
-                    extract_consumer_info(caller_ref)
-                  when Karafka::Connection::Client
-                    extract_client_info(caller_ref)
-                  when Karafka::Connection::Listener
-                    extract_listener_info(caller_ref)
-                  else
-                    {}
-                  end
+        when Karafka::BaseConsumer
+          extract_consumer_info(caller_ref)
+        when Karafka::Connection::Client
+          extract_client_info(caller_ref)
+        when Karafka::Connection::Listener
+          extract_listener_info(caller_ref)
+        else
+          {}
+        end
 
         return nil if details.empty?
 
-        "[#{details.map { |label, value| "#{label}: #{value}" }.join(', ')}]"
+        "[#{details.map { |label, value| "#{label}: #{value}" }.join(", ")}]"
       end
 
       # @param consumer [::Karafka::BaseConsumer]

data/lib/karafka/instrumentation/vendors/appsignal/base.rb

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-require_relative 'client'
+require_relative "client"
 
 module Karafka
   module Instrumentation

data/lib/karafka/instrumentation/vendors/appsignal/client.rb

@@ -148,7 +148,7 @@ module Karafka
           #   compatibility checks.
           def version_4_or_newer?
             @version_4_or_newer ||=
-              Gem::Version.new(::Appsignal::VERSION) >= Gem::Version.new('4.0.0')
+              Gem::Version.new(::Appsignal::VERSION) >= Gem::Version.new("4.0.0")
           end
         end
       end

data/lib/karafka/instrumentation/vendors/appsignal/errors_listener.rb

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-require_relative 'base'
+require_relative "base"
 
 module Karafka
   module Instrumentation

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

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-require_relative 'base'
+require_relative "base"
 
 module Karafka
   module Instrumentation
@@ -14,30 +14,30 @@ module Karafka
           # Value object for storing a single rdkafka metric publishing details
           RdKafkaMetric = Struct.new(:type, :scope, :name, :key_location)
 
-          setting :namespace, default: 'karafka'
+          setting :namespace, default: "karafka"
 
           setting :client, default: Client.new
 
           setting :rd_kafka_metrics, default: [
             # Broker metrics
-            RdKafkaMetric.new(:count, :brokers, 'requests_retries', 'txretries_d'),
-            RdKafkaMetric.new(:count, :brokers, 'transmission_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, "requests_retries", "txretries_d"),
+            RdKafkaMetric.new(:count, :brokers, "transmission_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 partitions metrics
-            RdKafkaMetric.new(:gauge, :topics, 'consumer_lag', 'consumer_lag_stored'),
-            RdKafkaMetric.new(:gauge, :topics, 'consumer_lag_delta', 'consumer_lag_stored_d')
+            RdKafkaMetric.new(:gauge, :topics, "consumer_lag", "consumer_lag_stored"),
+            RdKafkaMetric.new(:gauge, :topics, "consumer_lag_delta", "consumer_lag_stored_d")
           ].freeze
 
           # Metrics that sum values on topics levels and not on partition levels
           setting :aggregated_rd_kafka_metrics, default: [
             # Topic aggregated metrics
-            RdKafkaMetric.new(:gauge, :topics, 'consumer_aggregated_lag', 'consumer_lag_stored')
+            RdKafkaMetric.new(:gauge, :topics, "consumer_aggregated_lag", "consumer_lag_stored")
           ].freeze
 
           configure
@@ -65,7 +65,7 @@ module Karafka
           def on_consumer_consume(event)
             consumer = event.payload[:caller]
 
-            start_transaction(consumer, 'consume')
+            start_transaction(consumer, "consume")
 
             client.metadata = {
               batch_size: consumer.messages.size,
@@ -87,9 +87,9 @@ module Karafka
             metadata = messages.metadata
 
             with_multiple_resolutions(consumer) do |tags|
-              count('consumer_messages', messages.size, tags)
-              count('consumer_batches', 1, tags)
-              gauge('consumer_offsets', metadata.last_offset, tags)
+              count("consumer_messages", messages.size, tags)
+              count("consumer_batches", 1, tags)
+              gauge("consumer_offsets", metadata.last_offset, tags)
             end
 
             stop_transaction
@@ -140,7 +140,7 @@ module Karafka
             consumer = event.payload[:caller]
 
             with_multiple_resolutions(consumer) do |tags|
-              count('consumer_dead', 1, tags)
+              count("consumer_dead", 1, tags)
             end
           end
 
@@ -154,7 +154,7 @@ module Karafka
               consumer = event.payload[:caller]
 
               with_multiple_resolutions(consumer) do |tags|
-                count('consumer_errors', 1, tags)
+                count("consumer_errors", 1, tags)
               end
             end
 
@@ -186,32 +186,32 @@ module Karafka
               # way from other places
               nil
             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
 
                 public_send(
                   metric.type,
                   metric.name,
                   broker_statistics.dig(*metric.key_location),
                   {
-                    broker: broker_statistics['nodename']
+                    broker: broker_statistics["nodename"]
                   }
                 )
               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"
 
                   public_send(
                     metric.type,
@@ -236,14 +236,14 @@ module Karafka
           # @param consumer_group_id [String] cg in context which we operate
           def report_aggregated_topics_metrics(statistics, consumer_group_id)
             config.aggregated_rd_kafka_metrics.each do |metric|
-              statistics.fetch('topics').each do |topic_name, topic_values|
+              statistics.fetch("topics").each do |topic_name, topic_values|
                 sum = 0
 
-                topic_values['partitions'].each do |partition_name, partition_statistics|
-                  next if partition_name == '-1'
+                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
 
                   sum += partition_statistics.dig(*metric.key_location)
                 end
@@ -330,8 +330,8 @@ module Karafka
           def minute_probe
             concurrency = Karafka::App.config.concurrency
 
-            count('processes_count', 1, {})
-            count('threads_count', concurrency, {})
+            count("processes_count", 1, {})
+            count("threads_count", concurrency, {})
           end
         end
       end