karafka 2.5.1 → 2.5.2

data/lib/karafka/pro/routing/features/direct_assignments/subscription_group.rb

@@ -13,6 +13,10 @@ module Karafka
           # Extension allowing us to select correct subscriptions and assignments based on the
           # expanded routing setup
           module SubscriptionGroup
+            include Helpers::ConfigImporter.new(
+              swarm_node: %i[swarm node]
+            )
+
             # @return [false, Array<String>] false if we do not have any subscriptions or array
             #   with all the subscriptions for given subscription group
             def subscriptions
@@ -30,8 +34,7 @@ module Karafka
               topics
                 .select(&:active?)
                 .select { |topic| topic.direct_assignments.active? }
-                .map { |topic| build_assignments(topic) }
-                .to_h
+                .to_h { |topic| build_assignments(topic) }
                 .tap { |topics| return false if topics.empty? }
                 .then { |topics| Iterator::Expander.new.call(topics) }
                 .then { |topics| Iterator::TplBuilder.new(consumer, topics).call }
@@ -44,21 +47,19 @@ module Karafka
             # @param topic [Karafka::Routing::Topic]
             # @return [Array<String, Hash>]
             def build_assignments(topic)
-              node = Karafka::App.config.swarm.node
-
               standard_setup = [
                 topic.subscription_name,
                 topic.direct_assignments.partitions
               ]
 
-              return standard_setup unless node
+              return standard_setup unless swarm_node
               # Unless user explicitly assigned particular partitions to particular nodes, we just
               # go with full regular assignments
               return standard_setup unless topic.swarm.nodes.is_a?(Hash)
 
               [
                 topic.subscription_name,
-                topic.swarm.nodes.fetch(node.id).map { |partition| [partition, true] }.to_h
+                topic.swarm.nodes.fetch(swarm_node.id).to_h { |partition| [partition, true] }
               ]
             end
           end

data/lib/karafka/pro/routing/features/direct_assignments/topic.rb

@@ -43,12 +43,12 @@ module Karafka
 
                 Config.new(
                   active: true,
-                  partitions: partitions_or_all.map { |partition| [partition, true] }.to_h
+                  partitions: partitions_or_all.to_h { |partition| [partition, true] }
                 )
               else
                 Config.new(
                   active: !partitions_or_all.empty?,
-                  partitions: partitions_or_all.map { |partition| [partition, true] }.to_h
+                  partitions: partitions_or_all.to_h { |partition| [partition, true] }
                 )
               end
             end

data/lib/karafka/pro/routing/features/expiring/contracts/topic.rb

@@ -13,10 +13,8 @@ module Karafka
             # Contract to validate configuration of the expiring feature
             class Topic < Karafka::Contracts::Base
               configure do |config|
-                config.error_messages = YAML.safe_load(
-                  File.read(
-                    File.join(Karafka.gem_root, 'config', 'locales', 'pro_errors.yml')
-                  )
+                config.error_messages = YAML.safe_load_file(
+                  File.join(Karafka.gem_root, 'config', 'locales', 'pro_errors.yml')
                 ).fetch('en').fetch('validations').fetch('routing').fetch('topic')
               end
 

data/lib/karafka/pro/routing/features/expiring/topic.rb

@@ -35,10 +35,8 @@ module Karafka
             end
 
             # Just an alias for nice API
-            #
-            # @param args [Array] Anything `#expiring` accepts
-            def expire_in(*args)
-              expiring(*args)
+            def expire_in(*)
+              expiring(*)
             end
 
             # @return [Boolean] is a given job expiring

data/lib/karafka/pro/routing/features/filtering/contracts/topic.rb

@@ -13,10 +13,8 @@ module Karafka
             # Contract to validate configuration of the filtering feature
             class Topic < Karafka::Contracts::Base
               configure do |config|
-                config.error_messages = YAML.safe_load(
-                  File.read(
-                    File.join(Karafka.gem_root, 'config', 'locales', 'pro_errors.yml')
-                  )
+                config.error_messages = YAML.safe_load_file(
+                  File.join(Karafka.gem_root, 'config', 'locales', 'pro_errors.yml')
                 ).fetch('en').fetch('validations').fetch('routing').fetch('topic')
               end
 

data/lib/karafka/pro/routing/features/filtering/topic.rb

@@ -27,10 +27,9 @@ module Karafka
               @filtering
             end
 
-            # @param args [Array] Anything `#filter` accepts
             # @return [Filtering::Config] alias to match the naming API for features
-            def filtering(*args)
-              filter(*args)
+            def filtering(*)
+              filter(*)
             end
 
             # @return [Boolean] is a given job throttled

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

@@ -13,10 +13,8 @@ module Karafka
             # Contract for inline insights topic setup
             class Topic < Karafka::Contracts::Base
               configure do |config|
-                config.error_messages = YAML.safe_load(
-                  File.read(
-                    File.join(Karafka.gem_root, 'config', 'locales', 'pro_errors.yml')
-                  )
+                config.error_messages = YAML.safe_load_file(
+                  File.join(Karafka.gem_root, 'config', 'locales', 'pro_errors.yml')
                 ).fetch('en').fetch('validations').fetch('routing').fetch('topic')
               end
 

data/lib/karafka/pro/routing/features/long_running_job/contracts/topic.rb

@@ -13,10 +13,8 @@ module Karafka
             # Rules around long-running job settings
             class Topic < Karafka::Contracts::Base
               configure do |config|
-                config.error_messages = YAML.safe_load(
-                  File.read(
-                    File.join(Karafka.gem_root, 'config', 'locales', 'pro_errors.yml')
-                  )
+                config.error_messages = YAML.safe_load_file(
+                  File.join(Karafka.gem_root, 'config', 'locales', 'pro_errors.yml')
                 ).fetch('en').fetch('validations').fetch('routing').fetch('topic')
               end
 

data/lib/karafka/pro/routing/features/multiplexing/contracts/topic.rb

@@ -17,10 +17,8 @@ module Karafka
             # multiplexing attributes are optional since multiplexing may not be enabled
             class Topic < Karafka::Contracts::Base
               configure do |config|
-                config.error_messages = YAML.safe_load(
-                  File.read(
-                    File.join(Karafka.gem_root, 'config', 'locales', 'pro_errors.yml')
-                  )
+                config.error_messages = YAML.safe_load_file(
+                  File.join(Karafka.gem_root, 'config', 'locales', 'pro_errors.yml')
                 ).fetch('en').fetch('validations').fetch('routing').fetch('topic')
               end
 
@@ -56,7 +54,7 @@ module Karafka
                 max = max(data)
                 boot = boot(data)
 
-                next if boot >= min && boot <= max
+                next if boot.between?(min, max)
 
                 [[%w[subscription_group_details], :multiplexing_boot_mismatch]]
               end

data/lib/karafka/pro/routing/features/non_blocking_job/topic.rb

@@ -10,9 +10,9 @@ module Karafka
         class NonBlockingJob < Base
           # Non-Blocking Jobs topic API extensions
           module Topic
-            # @param args [Array] anything accepted by the `#long_running_job` API
-            def non_blocking_job(*args)
-              long_running_job(*args)
+            # Non blocking setting method
+            def non_blocking_job(*)
+              long_running_job(*)
             end
 
             alias non_blocking non_blocking_job

data/lib/karafka/pro/routing/features/offset_metadata/contracts/topic.rb

@@ -13,10 +13,8 @@ module Karafka
             # Contract to validate configuration of the expiring feature
             class Topic < Karafka::Contracts::Base
               configure do |config|
-                config.error_messages = YAML.safe_load(
-                  File.read(
-                    File.join(Karafka.gem_root, 'config', 'locales', 'pro_errors.yml')
-                  )
+                config.error_messages = YAML.safe_load_file(
+                  File.join(Karafka.gem_root, 'config', 'locales', 'pro_errors.yml')
                 ).fetch('en').fetch('validations').fetch('routing').fetch('topic')
               end
 

data/lib/karafka/pro/routing/features/parallel_segments/contracts/consumer_group.rb

@@ -13,10 +13,8 @@ module Karafka
             # Contract to validate configuration of the parallel segments feature
             class ConsumerGroup < Karafka::Contracts::Base
               configure do |config|
-                config.error_messages = YAML.safe_load(
-                  File.read(
-                    File.join(Karafka.gem_root, 'config', 'locales', 'pro_errors.yml')
-                  )
+                config.error_messages = YAML.safe_load_file(
+                  File.join(Karafka.gem_root, 'config', 'locales', 'pro_errors.yml')
                 ).fetch('en').fetch('validations').fetch('routing').fetch('consumer_group')
 
                 nested(:parallel_segments) do

data/lib/karafka/pro/routing/features/patterns/contracts/consumer_group.rb

@@ -12,13 +12,11 @@ module Karafka
             # Contract to validate configuration of the filtering feature
             class ConsumerGroup < Karafka::Contracts::Base
               configure do |config|
-                config.error_messages = YAML.safe_load(
-                  File.read(
-                    File.join(Karafka.gem_root, 'config', 'locales', 'pro_errors.yml')
-                  )
+                config.error_messages = YAML.safe_load_file(
+                  File.join(Karafka.gem_root, 'config', 'locales', 'pro_errors.yml')
                 ).fetch('en').fetch('validations').fetch('routing').fetch('consumer_group')
 
-                required(:patterns) { |val| val.is_a?(Array) && val.all? { |el| el.is_a?(Hash) } }
+                required(:patterns) { |val| val.is_a?(Array) && val.all?(Hash) }
 
                 virtual do |data, errors|
                   next unless errors.empty?

data/lib/karafka/pro/routing/features/patterns/contracts/pattern.rb

@@ -13,10 +13,8 @@ module Karafka
             # Contract used to validate pattern data
             class Pattern < Karafka::Contracts::Base
               configure do |config|
-                config.error_messages = YAML.safe_load(
-                  File.read(
-                    File.join(Karafka.gem_root, 'config', 'locales', 'pro_errors.yml')
-                  )
+                config.error_messages = YAML.safe_load_file(
+                  File.join(Karafka.gem_root, 'config', 'locales', 'pro_errors.yml')
                 ).fetch('en').fetch('validations').fetch('pattern')
 
                 required(:regexp) { |val| val.is_a?(Regexp) }

data/lib/karafka/pro/routing/features/patterns/contracts/topic.rb

@@ -13,10 +13,8 @@ module Karafka
             # Contract to validate configuration of the patterns feature
             class Topic < Karafka::Contracts::Base
               configure do |config|
-                config.error_messages = YAML.safe_load(
-                  File.read(
-                    File.join(Karafka.gem_root, 'config', 'locales', 'pro_errors.yml')
-                  )
+                config.error_messages = YAML.safe_load_file(
+                  File.join(Karafka.gem_root, 'config', 'locales', 'pro_errors.yml')
                 ).fetch('en').fetch('validations').fetch('routing').fetch('topic')
               end
 

data/lib/karafka/pro/routing/features/pausing/config.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+# This code is part of Karafka Pro, a commercial component not licensed under LGPL.
+# See LICENSE for details.
+
+module Karafka
+  module Pro
+    module Routing
+      module Features
+        class Pausing < Base
+          # Config for pausing feature
+          Config = Struct.new(
+            :active,
+            :timeout,
+            :max_timeout,
+            :with_exponential_backoff,
+            keyword_init: true
+          ) do
+            alias_method :active?, :active
+            alias_method :with_exponential_backoff?, :with_exponential_backoff
+          end
+        end
+      end
+    end
+  end
+end

data/lib/karafka/pro/routing/features/pausing/contracts/topic.rb

@@ -13,25 +13,31 @@ module Karafka
             # Contract to make sure, that the pause settings on a per topic basis are as expected
             class Topic < Karafka::Contracts::Base
               configure do |config|
-                config.error_messages = YAML.safe_load(
-                  File.read(
-                    File.join(Karafka.gem_root, 'config', 'locales', 'pro_errors.yml')
-                  )
+                config.error_messages = YAML.safe_load_file(
+                  File.join(Karafka.gem_root, 'config', 'locales', 'pro_errors.yml')
                 ).fetch('en').fetch('validations').fetch('routing').fetch('topic')
 
-                required(:pause_timeout) { |val| val.is_a?(Integer) && val.positive? }
-                required(:pause_max_timeout) { |val| val.is_a?(Integer) && val.positive? }
-                required(:pause_with_exponential_backoff) { |val| [true, false].include?(val) }
+                # Validate the nested pausing configuration
+                # Both old setters and new pause() method update the pausing config,
+                # so we only need to validate this one format
+                nested :pausing do
+                  required(:active) { |val| [true, false].include?(val) }
+                  required(:timeout) { |val| val.is_a?(Integer) && val.positive? }
+                  required(:max_timeout) { |val| val.is_a?(Integer) && val.positive? }
+                  required(:with_exponential_backoff) { |val| [true, false].include?(val) }
+                end
 
+                # Validate that timeout <= max_timeout
                 virtual do |data, errors|
                   next unless errors.empty?
 
-                  pause_timeout = data.fetch(:pause_timeout)
-                  pause_max_timeout = data.fetch(:pause_max_timeout)
+                  pausing = data.fetch(:pausing)
+                  timeout = pausing.fetch(:timeout)
+                  max_timeout = pausing.fetch(:max_timeout)
 
-                  next if pause_timeout <= pause_max_timeout
+                  next if timeout <= max_timeout
 
-                  [[%i[pause_timeout], :max_timeout_vs_pause_max_timeout]]
+                  [[%i[pausing timeout], :max_timeout_vs_pause_max_timeout]]
                 end
               end
             end

data/lib/karafka/pro/routing/features/pausing/topic.rb

@@ -10,23 +10,84 @@ module Karafka
         class Pausing < Base
           # Expansion allowing for a per topic pause strategy definitions
           module Topic
+            # This method calls the parent class initializer and then sets up the
+            # extra instance variable to nil. The explicit initialization
+            # to nil is included as an optimization for Ruby's object shapes system,
+            # which improves memory layout and access performance.
+            def initialize(...)
+              super
+              @pausing = nil
+            end
+
             # Allows for per-topic pausing strategy setting
             #
             # @param timeout [Integer] how long should we wait upon processing error (milliseconds)
             # @param max_timeout [Integer] what is the max timeout in case of an exponential
             #   backoff (milliseconds)
             # @param with_exponential_backoff [Boolean] should we use exponential backoff
-            #
-            # @note We do not construct here the nested config like we do with other routing
-            #   features, because this feature operates on the OSS layer by injection of values
-            #   and a nested config is not needed.
+            # @return [Config] pausing config object
             def pause(timeout: nil, max_timeout: nil, with_exponential_backoff: nil)
-              self.pause_timeout = timeout if timeout
-              self.pause_max_timeout = max_timeout if max_timeout
+              # If no arguments provided, just return or initialize the config
+              return pausing if timeout.nil? && max_timeout.nil? && with_exponential_backoff.nil?
+
+              # Update instance variables for backwards compatibility
+              # This ensures code reading @pause_timeout directly or via the inherited getter
+              # will get the correct values
+              @pause_timeout = timeout if timeout
+              @pause_max_timeout = max_timeout if max_timeout
+
+              unless with_exponential_backoff.nil?
+                @pause_with_exponential_backoff = with_exponential_backoff
+              end
+
+              # Create or update the config
+              @pausing ||= Config.new(
+                active: false,
+                timeout: @pause_timeout || Karafka::App.config.pause.timeout,
+                max_timeout: @pause_max_timeout || Karafka::App.config.pause.max_timeout,
+                with_exponential_backoff: if @pause_with_exponential_backoff.nil?
+                                            Karafka::App.config.pause.with_exponential_backoff
+                                          else
+                                            @pause_with_exponential_backoff
+                                          end
+              )
+
+              @pausing.timeout = timeout if timeout
+              @pausing.max_timeout = max_timeout if max_timeout
 
-              return unless with_exponential_backoff
+              unless with_exponential_backoff.nil?
+                @pausing.with_exponential_backoff = with_exponential_backoff
+              end
+
+              @pausing.active = true
+
+              @pausing
+            end
+
+            # @return [Config] pausing configuration object
+            def pausing
+              @pausing ||= Config.new(
+                active: false,
+                timeout: @pause_timeout || Karafka::App.config.pause.timeout,
+                max_timeout: @pause_max_timeout || Karafka::App.config.pause.max_timeout,
+                with_exponential_backoff: if @pause_with_exponential_backoff.nil?
+                                            Karafka::App.config.pause.with_exponential_backoff
+                                          else
+                                            @pause_with_exponential_backoff
+                                          end
+              )
+            end
+
+            # @return [Boolean] is pausing explicitly configured
+            def pausing?
+              pausing.active?
+            end
 
-              self.pause_with_exponential_backoff = with_exponential_backoff
+            # @return [Hash] topic with all its native configuration options plus pausing settings
+            def to_h
+              super.merge(
+                pausing: pausing.to_h
+              ).freeze
             end
           end
         end

data/lib/karafka/pro/routing/features/periodic_job/contracts/topic.rb

@@ -13,10 +13,8 @@ module Karafka
             # Contract to validate configuration of the periodics feature
             class Topic < Karafka::Contracts::Base
               configure do |config|
-                config.error_messages = YAML.safe_load(
-                  File.read(
-                    File.join(Karafka.gem_root, 'config', 'locales', 'pro_errors.yml')
-                  )
+                config.error_messages = YAML.safe_load_file(
+                  File.join(Karafka.gem_root, 'config', 'locales', 'pro_errors.yml')
                 ).fetch('en').fetch('validations').fetch('routing').fetch('topic')
               end
 

data/lib/karafka/pro/routing/features/recurring_tasks/contracts/topic.rb

@@ -13,10 +13,8 @@ module Karafka
             # Rules around recurring tasks settings
             class Topic < Karafka::Contracts::Base
               configure do |config|
-                config.error_messages = YAML.safe_load(
-                  File.read(
-                    File.join(Karafka.gem_root, 'config', 'locales', 'pro_errors.yml')
-                  )
+                config.error_messages = YAML.safe_load_file(
+                  File.join(Karafka.gem_root, 'config', 'locales', 'pro_errors.yml')
                 ).fetch('en').fetch('validations').fetch('routing').fetch('topic')
               end
 

data/lib/karafka/pro/routing/features/scheduled_messages/contracts/topic.rb

@@ -13,10 +13,8 @@ module Karafka
             # Rules around scheduled messages settings
             class Topic < Karafka::Contracts::Base
               configure do |config|
-                config.error_messages = YAML.safe_load(
-                  File.read(
-                    File.join(Karafka.gem_root, 'config', 'locales', 'pro_errors.yml')
-                  )
+                config.error_messages = YAML.safe_load_file(
+                  File.join(Karafka.gem_root, 'config', 'locales', 'pro_errors.yml')
                 ).fetch('en').fetch('validations').fetch('routing').fetch('topic')
               end
 

data/lib/karafka/pro/routing/features/swarm/contracts/routing.rb

@@ -18,10 +18,8 @@ module Karafka
             # This is why we use it before warmup when everything is expected to be configured.
             class Routing < Karafka::Contracts::Base
               configure do |config|
-                config.error_messages = YAML.safe_load(
-                  File.read(
-                    File.join(Karafka.gem_root, 'config', 'locales', 'pro_errors.yml')
-                  )
+                config.error_messages = YAML.safe_load_file(
+                  File.join(Karafka.gem_root, 'config', 'locales', 'pro_errors.yml')
                 ).fetch('en').fetch('validations').fetch('routing')
               end
 

data/lib/karafka/pro/routing/features/swarm/contracts/topic.rb

@@ -13,10 +13,8 @@ module Karafka
             # Contract to validate configuration of the swarm feature
             class Topic < Karafka::Contracts::Base
               configure do |config|
-                config.error_messages = YAML.safe_load(
-                  File.read(
-                    File.join(Karafka.gem_root, 'config', 'locales', 'pro_errors.yml')
-                  )
+                config.error_messages = YAML.safe_load_file(
+                  File.join(Karafka.gem_root, 'config', 'locales', 'pro_errors.yml')
                 ).fetch('en').fetch('validations').fetch('routing').fetch('topic')
               end
 
@@ -25,15 +23,15 @@ module Karafka
 
                 required(:nodes) do |val|
                   next true if val.is_a?(Range)
-                  next true if val.is_a?(Array) && val.all? { |id| id.is_a?(Integer) }
+                  next true if val.is_a?(Array) && val.all?(Integer)
                   next false unless val.is_a?(Hash)
-                  next false unless val.keys.all? { |id| id.is_a?(Integer) }
+                  next false unless val.keys.all?(Integer)
 
                   values = val.values
 
                   next false unless values.all? { |ps| ps.is_a?(Array) || ps.is_a?(Range) }
-                  next true if values.flatten.all? { |part| part.is_a?(Integer) }
-                  next true if values.flatten.all? { |part| part.is_a?(Range) }
+                  next true if values.flatten.all?(Integer)
+                  next true if values.flatten.all?(Range)
 
                   false
                 end

data/lib/karafka/pro/routing/features/throttling/contracts/topic.rb

@@ -13,10 +13,8 @@ module Karafka
             # Rules around throttling settings
             class Topic < Karafka::Contracts::Base
               configure do |config|
-                config.error_messages = YAML.safe_load(
-                  File.read(
-                    File.join(Karafka.gem_root, 'config', 'locales', 'pro_errors.yml')
-                  )
+                config.error_messages = YAML.safe_load_file(
+                  File.join(Karafka.gem_root, 'config', 'locales', 'pro_errors.yml')
                 ).fetch('en').fetch('validations').fetch('routing').fetch('topic')
               end
 

data/lib/karafka/pro/routing/features/virtual_partitions/contracts/topic.rb

@@ -13,10 +13,8 @@ module Karafka
             # Rules around virtual partitions
             class Topic < Karafka::Contracts::Base
               configure do |config|
-                config.error_messages = YAML.safe_load(
-                  File.read(
-                    File.join(Karafka.gem_root, 'config', 'locales', 'pro_errors.yml')
-                  )
+                config.error_messages = YAML.safe_load_file(
+                  File.join(Karafka.gem_root, 'config', 'locales', 'pro_errors.yml')
                 ).fetch('en').fetch('validations').fetch('routing').fetch('topic')
               end
 

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

@@ -11,10 +11,8 @@ module Karafka
         # Makes sure, all the expected config is defined as it should be
         class Config < ::Karafka::Contracts::Base
           configure do |config|
-            config.error_messages = YAML.safe_load(
-              File.read(
-                File.join(Karafka.gem_root, 'config', 'locales', 'pro_errors.yml')
-              )
+            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')
           end
 

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

@@ -13,10 +13,8 @@ module Karafka
         # details to be able to dispatch the message
         class Message < ::Karafka::Contracts::Base
           configure do |config|
-            config.error_messages = YAML.safe_load(
-              File.read(
-                File.join(Karafka.gem_root, 'config', 'locales', 'pro_errors.yml')
-              )
+            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')
           end
 

data/lib/karafka/pro/scheduled_messages.rb

@@ -24,17 +24,15 @@ module Karafka
 
       class << self
         # Runs the `Proxy.call`
-        # @param kwargs [Hash] things requested by the proxy
         # @return [Hash] message wrapped with the scheduled message envelope
-        def schedule(**kwargs)
-          Proxy.schedule(**kwargs)
+        def schedule(**)
+          Proxy.schedule(**)
         end
 
         # Generates a tombstone message to cancel given dispatch (if not yet happened)
-        # @param kwargs [Hash] things requested by the proxy
         # @return [Hash] tombstone cancelling message
-        def cancel(**kwargs)
-          Proxy.cancel(**kwargs)
+        def cancel(**)
+          Proxy.cancel(**)
         end
 
         # Below are private APIs

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

@@ -171,14 +171,14 @@ module Karafka
         def rss_mb_linux
           kb_rss = 0
 
-          IO.readlines("/proc/#{node.pid}/status").each do |line|
+          File.readlines("/proc/#{node.pid}/status").each do |line|
             next unless line.start_with?('VmRSS:')
 
             kb_rss = line.split[1].to_i
             break
           end
 
-          (kb_rss / 1_024.to_i).round
+          (kb_rss / 1_024).round
         rescue Errno::ENOENT, Errno::EACCES
           # /proc file doesn't exist or no permission to read it
           0

data/lib/karafka/processing/coordinator.rb

@@ -198,8 +198,6 @@ module Karafka
 
       # Allows to run synchronized (locked) code that can operate only from a given thread
       #
-      # @param block [Proc] code we want to run in the synchronized mode
-      #
       # @note We check if mutex is not owned already by the current thread so we won't end up with
       #   a deadlock in case user runs coordinated code from inside of his own lock
       #
@@ -207,11 +205,11 @@ module Karafka
       #   Otherwise user indirectly could cause deadlocks or prolonged locks by running his logic.
       #   This can and should however be used for multi-thread strategy applications and other
       #   internal operations locks.
-      def synchronize(&block)
+      def synchronize(&)
         if @mutex.owned?
           yield
         else
-          @mutex.synchronize(&block)
+          @mutex.synchronize(&)
         end
       end
     end