karafka-web 0.11.2 → 0.11.4

data/lib/karafka/web/ui/models/message.rb

@@ -146,9 +146,9 @@ module Karafka
             # @param page [Integer] which page we want to get
             def topic_page(topic_id, partitions_ids, page)
               # This is the bottleneck, for each partition we make one request :(
-              offsets = partitions_ids.map do |partition_id|
+              offsets = partitions_ids.to_h do |partition_id|
                 [partition_id, Models::WatermarkOffsets.find(topic_id, partition_id)]
-              end.to_h
+              end
 
               # Count number of elements we have in each partition
               # This assumes linear presence until low. If not, gaps will be filled like we fill
@@ -158,7 +158,7 @@ module Karafka
               # Establish initial offsets for the iterator (where to start) per partition
               # We do not use the negative lookup iterator because we already can compute starting
               # offsets. This saves a lot of calls to Kafka
-              ranges = Sets.call(counts, page).map do |partition_position, partition_range|
+              ranges = Sets.call(counts, page).to_h do |partition_position, partition_range|
                 partition_id = partitions_ids.to_a[partition_position]
                 watermarks = offsets[partition_id]
 
@@ -169,7 +169,7 @@ module Karafka
 
                 # This range represents offsets we want to fetch
                 [partition_id, lowest..highest]
-              end.to_h
+              end
 
               # We start on our topic from the lowest offset for each expected partition
               iterator = Karafka::Pro::Iterator.new(
@@ -208,18 +208,17 @@ module Karafka
               end
 
               [
-                aggregated.values.map(&:values).map(&:reverse).reduce(:+),
+                aggregated.values.sum([]) { |partition| partition.values.reverse },
                 !Sets.call(counts, page + 1).empty?
               ]
             end
 
             private
 
-            # @param args [Object] anything required by the admin `#read_topic`
             # @return [Array<Karafka::Messages::Message>, false] topic partition messages or false
             #   in case we hit a non-existing offset
-            def read_topic(*args)
-              Lib::Admin.read_topic(*args)
+            def read_topic(*)
+              Lib::Admin.read_topic(*)
             rescue Rdkafka::RdkafkaError => e
               return false if e.code == :auto_offset_reset
 

data/lib/karafka/web/ui/models/metrics/aggregated.rb

@@ -103,10 +103,10 @@ module Karafka
                   base = sample.last.dup
 
                   DELTA_KEYS.each do |key|
-                    base[key] = previous.last[key] + (sample.last[key] - previous.last[key]) / 2
+                    base[key] = previous.last[key] + ((sample.last[key] - previous.last[key]) / 2)
                   end
 
-                  filled << [previous.first + (sample.first - previous.first) / 2, base]
+                  filled << [previous.first + ((sample.first - previous.first) / 2), base]
                 end
 
                 filled << sample
@@ -182,12 +182,12 @@ module Karafka
             # @param current [Hash]
             # @return [Hash] delta computed values
             def compute_deltas(previous, current)
-              DELTA_KEYS.map do |delta_key|
+              DELTA_KEYS.to_h do |delta_key|
                 [
                   delta_key,
                   current.fetch(delta_key) - previous.fetch(delta_key)
                 ]
-              end.to_h
+              end
             end
           end
         end

data/lib/karafka/web/ui/models/metrics/charts/aggregated.rb

@@ -38,8 +38,7 @@ module Karafka
               # @return [String] JSON with data about all the charts we were interested in
               def with(*args)
                 args
-                  .map { |name| [name.to_sym, public_send(name)] }
-                  .to_h
+                  .to_h { |name| [name.to_sym, public_send(name)] }
                   .to_json
               end
 

data/lib/karafka/web/ui/models/metrics/charts/topics.rb

@@ -36,11 +36,11 @@ module Karafka
                 end
 
                 # Extract the lag stored only from all the data
-                per_topic = @data.to_h.map do |topic, metrics|
+                per_topic = @data.to_h.to_h do |topic, metrics|
                   extracted = metrics.map { |metric| [metric.first, metric.last[:lag_hybrid]] }
 
                   [topic, extracted]
-                end.to_h
+                end
 
                 # We name it with a space because someone may have a topic called "total" and we
                 # want to avoid collisions

data/lib/karafka/web/ui/models/metrics/topics.rb

@@ -43,9 +43,9 @@ module Karafka
 
                 # Always align the order of topics in hash based on their name so it is
                 # independent from the reported order
-                extracted[range] = range_extracted.keys.sort.map do |key|
+                extracted[range] = range_extracted.keys.sort.to_h do |key|
                   [key, range_extracted[key]]
-                end.to_h
+                end
               end
 
               extracted
@@ -67,8 +67,7 @@ module Karafka
                              .select { |val| val.is_a?(Hash) }
                              .flat_map(&:keys)
                              .uniq
-                             .map { |key| [key, nil] }
-                             .to_h
+                             .to_h { |key| [key, nil] }
                              .freeze
 
               # Normalize data in between topics reportings

data/lib/karafka/web/ui/models/recurring_tasks/schedule.rb

@@ -50,7 +50,7 @@ module Karafka
                 new(candidate.payload)
               rescue Rdkafka::RdkafkaError => e
                 # If any of "topic missing" is raised, we return false but other errors we re-raise
-                raise(e) unless EXPECTED_RDKAFKA_ERRORS.any? { |code| e.code == code }
+                raise(e) unless EXPECTED_RDKAFKA_ERRORS.include?(e.code)
 
                 false
               end