rubocop: reduce redundant block.call for performance

This is cosmetic change, it does not change behavior at all. The following rubocop configuration detects it.

```
Performance/RedundantBlockCall:
  Enable: true
```

Benchmark result:

```
ruby 3.2.8 (2025-03-26 revision 13f495dc2c) +YJIT [x86_64-linux]
Warming up --------------------------------------
          block call     1.296M i/100ms
   yield with &block     1.708M i/100ms
yield without &block     1.687M i/100ms
Calculating -------------------------------------
          block call     12.964M (± 0.8%) i/s   (77.14 ns/i) -     66.097M in   5.098814s
   yield with &block     17.186M (± 0.5%) i/s   (58.19 ns/i) -     87.092M in   5.067659s
yield without &block     17.162M (± 0.3%) i/s   (58.27 ns/i) -     86.062M in   5.014579s

Comparison:
   yield with &block: 17186340.4 i/s
yield without &block: 17162477.2 i/s - same-ish: difference falls within error
          block call: 12964086.6 i/s - 1.33x  slower
```

yield with/without &block is same-ish. For simplicity, use without &block.

Appendix: benchmark script

```ruby
require 'bundler/inline'
gemfile do
  source 'https://rubygems.org'
  gem 'benchmark-ips'
  gem 'benchmark-memory'
end

def block_call(s, &block)
  block.call(s) if block_given?
end

def yield_with_block(s, &block)
  yield(s) if block_given?
end

def yield_without_block(s)
  yield(s) if block_given?
end

Benchmark.ips do |x|
  x.report("block call") {
    block_call("dummy") do |message|
      message
    end
  }
  x.report("yield with &block") {
    yield_with_block("dummy") do |message|
      message
    end
  }
  x.report("yield without &block") {
    yield_without_block("dummy") do |message|
      message
    end
  }
  x.compare!
end
```

Signed-off-by: Kentaro Hayashi <hayashi@clear-code.com>

Author: kenhys

lib/fluent/compat/output.rb

@@ -404,14 +404,14 @@ def start
         end
       end
 
-      def detach_process(&block)
+      def detach_process
         log.warn "detach_process is not supported in this version. ignored."
-        block.call
+        yield
       end
 
-      def detach_multi_process(&block)
+      def detach_multi_process
         log.warn "detach_process is not supported in this version. ignored."
-        block.call
+        yield
       end
     end
 
@@ -541,14 +541,14 @@ def start
         end
       end
 
-      def detach_process(&block)
+      def detach_process
         log.warn "detach_process is not supported in this version. ignored."
-        block.call
+        yield
       end
 
-      def detach_multi_process(&block)
+      def detach_multi_process
         log.warn "detach_process is not supported in this version. ignored."
-        block.call
+        yield
       end
     end
 
@@ -698,14 +698,14 @@ def start
         end
       end
 
-      def detach_process(&block)
+      def detach_process
         log.warn "detach_process is not supported in this version. ignored."
-        block.call
+        yield
       end
 
-      def detach_multi_process(&block)
+      def detach_multi_process
         log.warn "detach_process is not supported in this version. ignored."
-        block.call
+        yield
       end
 
       # Original TimeSlicedOutput#emit doesn't call #format_stream

lib/fluent/config/element.rb

@@ -127,10 +127,10 @@ def [](key)
         super
       end
 
-      def check_not_fetched(&block)
+      def check_not_fetched
         each_key { |key|
           if @unused.include?(key)
-            block.call(key, self)
+            yield(key, self) if block_given?
           end
         }
         @elements.each { |e|

lib/fluent/event.rb

@@ -106,8 +106,8 @@ def slice(index, num)
       end
     end
 
-    def each(unpacker: nil, &block)
-      block.call(@time, @record)
+    def each(unpacker: nil)
+      yield(@time, @record)
       nil
     end
   end
@@ -189,11 +189,11 @@ def slice(index, num)
       MultiEventStream.new(@time_array.slice(index, num), @record_array.slice(index, num))
     end
 
-    def each(unpacker: nil, &block)
+    def each(unpacker: nil)
       time_array = @time_array
       record_array = @record_array
       for i in 0..time_array.length-1
-        block.call(time_array[i], record_array[i])
+        yield(time_array[i], record_array[i])
       end
       nil
     end
@@ -253,10 +253,10 @@ def slice(index, num)
       MultiEventStream.new(@unpacked_times.slice(index, num), @unpacked_records.slice(index, num))
     end
 
-    def each(unpacker: nil, &block)
+    def each(unpacker: nil)
       ensure_unpacked!(unpacker: unpacker)
       @unpacked_times.each_with_index do |time, i|
-        block.call(time, @unpacked_records[i])
+        yield(time, @unpacked_records[i])
       end
       nil
     end

lib/fluent/log.rb

@@ -309,11 +309,11 @@ def on_trace
       yield
     end
 
-    def trace(*args, &block)
+    def trace(*args)
       return if @level > LEVEL_TRACE
       type = log_type(args)
       return if skipped_type?(type)
-      args << block.call if block
+      args << yield if block_given?
       time, msg = event(:trace, args)
       return if time.nil?
       puts [@color_trace, @formatter.call(type, time, LEVEL_TRACE, msg), @color_reset].join
@@ -331,11 +331,11 @@ def on_debug
       yield
     end
 
-    def debug(*args, &block)
+    def debug(*args)
       return if @level > LEVEL_DEBUG
       type = log_type(args)
       return if skipped_type?(type)
-      args << block.call if block
+      args << yield if block_given?
       time, msg = event(:debug, args)
       return if time.nil?
       puts [@color_debug, @formatter.call(type, time, LEVEL_DEBUG, msg), @color_reset].join
@@ -352,11 +352,11 @@ def on_info
       yield
     end
 
-    def info(*args, &block)
+    def info(*args)
       return if @level > LEVEL_INFO
       type = log_type(args)
       return if skipped_type?(type)
-      args << block.call if block
+      args << yield if block_given?
       time, msg = event(:info, args)
       return if time.nil?
       puts [@color_info, @formatter.call(type, time, LEVEL_INFO, msg), @color_reset].join
@@ -373,11 +373,11 @@ def on_warn
       yield
     end
 
-    def warn(*args, &block)
+    def warn(*args)
       return if @level > LEVEL_WARN
       type = log_type(args)
       return if skipped_type?(type)
-      args << block.call if block
+      args << yield if block_given?
       time, msg = event(:warn, args)
       return if time.nil?
       puts [@color_warn, @formatter.call(type, time, LEVEL_WARN, msg), @color_reset].join
@@ -394,11 +394,11 @@ def on_error
       yield
     end
 
-    def error(*args, &block)
+    def error(*args)
       return if @level > LEVEL_ERROR
       type = log_type(args)
       return if skipped_type?(type)
-      args << block.call if block
+      args << yield if block_given?
       time, msg = event(:error, args)
       return if time.nil?
       puts [@color_error, @formatter.call(type, time, LEVEL_ERROR, msg), @color_reset].join
@@ -415,11 +415,11 @@ def on_fatal
       yield
     end
 
-    def fatal(*args, &block)
+    def fatal(*args)
       return if @level > LEVEL_FATAL
       type = log_type(args)
       return if skipped_type?(type)
-      args << block.call if block
+      args << yield if block_given?
       time, msg = event(:fatal, args)
       return if time.nil?
       puts [@color_fatal, @formatter.call(type, time, LEVEL_FATAL, msg), @color_reset].join

lib/fluent/plugin/buffer.rb

@@ -650,7 +650,7 @@ class ShouldRetry < StandardError; end
       # 3. enqueue existing chunk & retry whole method if chunk was not empty
       # 4. go to step_by_step writing
 
-      def write_once(metadata, data, format: nil, size: nil, &block)
+      def write_once(metadata, data, format: nil, size: nil)
         return if data.empty?
 
         stored = false
@@ -701,7 +701,7 @@ def write_once(metadata, data, format: nil, size: nil, &block)
           end
 
           if stored
-            block.call(chunk, adding_bytesize)
+            yield(chunk, adding_bytesize)
           end
         end
 
@@ -726,7 +726,7 @@ def write_once(metadata, data, format: nil, size: nil, &block)
       # 2. append splits into the staged chunks as much as possible
       # 3. create unstaged chunk and append rest splits -> repeat it for all splits
 
-      def write_step_by_step(metadata, data, format, splits_count, &block)
+      def write_step_by_step(metadata, data, format, splits_count)
         splits = []
         if splits_count > data.size
           splits_count = data.size
@@ -855,7 +855,7 @@ def write_step_by_step(metadata, data, format, splits_count, &block)
           modified_chunks.last[:adding_bytesize] = chunk.bytesize - original_bytesize
         end
         modified_chunks.each do |data|
-          block.call(data[:chunk], data[:adding_bytesize], data[:errors])
+          yield(data[:chunk], data[:adding_bytesize], data[:errors])
         end
       rescue ShouldRetry
         modified_chunks.each do |data|

lib/fluent/plugin/in_forward.rb

@@ -239,7 +239,7 @@ def handle_connection(conn)
       end
     end
 
-    def read_messages(conn, &block)
+    def read_messages(conn)
       feeder = nil
       serializer = nil
       bytes = 0
@@ -250,7 +250,7 @@ def read_messages(conn, &block)
           if first == '{' || first == '[' # json
             parser = Yajl::Parser.new
             parser.on_parse_complete = ->(obj){
-              block.call(obj, bytes, serializer)
+              yield(obj, bytes, serializer)
               bytes = 0
             }
             serializer = :to_json.to_proc
@@ -260,7 +260,7 @@ def read_messages(conn, &block)
             serializer = :to_msgpack.to_proc
             feeder = ->(d){
               parser.feed_each(d){|obj|
-                block.call(obj, bytes, serializer)
+                yield(obj, bytes, serializer)
                 bytes = 0
               }
             }

lib/fluent/plugin/output.rb

@@ -972,9 +972,9 @@ def execute_chunking(tag, es, enqueue: false)
         end
       end
 
-      def write_guard(&block)
+      def write_guard
         begin
-          block.call
+          yield
         rescue Fluent::Plugin::Buffer::BufferOverflowError
           log.warn "failed to write data into buffer by buffer overflow", action: @buffer_config.overflow_action
           case @buffer_config.overflow_action

lib/fluent/plugin/parser_json.rb

@@ -93,10 +93,10 @@ def parser_type
         :text
       end
 
-      def parse_io(io, &block)
+      def parse_io(io)
         y = Yajl::Parser.new
         y.on_parse_complete = ->(record){
-          block.call(parse_time(record), record)
+          yield(parse_time(record), record)
         }
         y.parse(io, @stream_buffer_size)
       end

lib/fluent/plugin/storage_local.rb

@@ -158,8 +158,8 @@ def delete(key)
         @store.delete(key.to_s)
       end
 
-      def update(key, &block)
-        @store[key.to_s] = block.call(@store[key.to_s])
+      def update(key)
+        @store[key.to_s] = yield(@store[key.to_s])
       end
     end
   end

lib/fluent/plugin_helper/compat_parameters.rb

@@ -324,13 +324,13 @@ def compat_parameters_formatter(conf)
         conf
       end
 
-      def compat_parameters_copy_to_subsection_attributes(conf, params, &block)
+      def compat_parameters_copy_to_subsection_attributes(conf, params)
         hash = {}
         params.each do |compat, current|
           next unless current
           if conf.has_key?(compat)
             if block_given?
-              hash[current] = block.call(compat, conf[compat])
+              hash[current] = yield(compat, conf[compat])
             else
               hash[current] = conf[compat]
             end