fluentd 1.19.4 → 1.20.1

data/lib/fluent/plugin/in_tail.rb

@@ -20,16 +20,26 @@ require 'fluent/plugin/input'
 require 'fluent/config/error'
 require 'fluent/event'
 require 'fluent/plugin/buffer'
+require 'fluent/ext_monitor_require'
 require 'fluent/plugin/parser_multiline'
 require 'fluent/variable_store'
 require 'fluent/capability'
 require 'fluent/plugin/in_tail/position_file'
 require 'fluent/plugin/in_tail/group_watch'
+require 'fluent/plugin/in_tail/stat_watcher'
+require 'fluent/plugin/in_tail/dir_watcher'
+require 'fluent/plugin/in_tail/io_handler'
+require 'fluent/plugin/in_tail/tail_watcher'
+require 'fluent/plugin/in_tail/line_feeder'
+require 'fluent/plugin/in_tail/compatibility'
+require 'fluent/plugin/in_tail/worker_pool'
 require 'fluent/file_wrapper'
 
 module Fluent::Plugin
   class TailInput < Fluent::Plugin::Input
     include GroupWatch
+    include Compatibility
+    include DirWatcher
 
     Fluent::Plugin.register_input('tail', self)
 
@@ -54,12 +64,14 @@ module Fluent::Plugin
       @tails = {}
       @tails_rotate_wait = {}
       @pf_file = nil
+      @watcher_refresh_monitor = Monitor.new
       @pf = nil
       @ignore_list = []
       @shutdown_start_time = nil
       @metrics = nil
       @startup = true
       @capability = Fluent::Capability.new(:current_process)
+      initialize_dir_watchers
     end
 
     desc 'The paths to read. Multiple paths can be specified, separated by comma.'
@@ -87,6 +99,8 @@ module Fluent::Plugin
     config_param :refresh_interval, :time, default: 60
     desc 'The number of reading lines at each IO.'
     config_param :read_lines_limit, :integer, default: 1000
+    desc 'The number of threads used to parse tailed files. Set to 1 to keep parsing synchronous; 2 or more enables worker parsing. The default is 1.'
+    config_param :num_threads, :integer, default: 1
     desc 'The number of reading bytes per second'
     config_param :read_bytes_limit_per_second, :size, default: -1
     desc 'The interval of flushing the buffer for multiline format'
@@ -95,8 +109,12 @@ module Fluent::Plugin
     config_param :emit_unmatched_lines, :bool, default: false
     desc 'Enable the additional watch timer.'
     config_param :enable_watch_timer, :bool, default: true
-    desc 'Enable the stat watcher based on inotify.'
+    desc 'Enable stat watchers for individual files, using inotify where available.'
     config_param :enable_stat_watcher, :bool, default: true
+    desc 'Watch directories to discover files before refresh_interval. May use inotify regardless of enable_stat_watcher.'
+    config_param :enable_dir_watcher, :bool, default: false
+    desc 'Maximum number of directories watched at once. When exceeded, rotate the watched subset at each periodic refresh.'
+    config_param :dir_watcher_limit, :integer, default: 100
     desc 'The encoding of the input.'
     config_param :encoding, :string, default: nil
     desc "The original encoding of the input. If set, in_tail tries to encode string from this to 'encoding'. Must be set with 'encoding'. "
@@ -140,9 +158,22 @@ module Fluent::Plugin
 
       super
 
+      if @dir_watcher_limit <= 0
+        raise Fluent::ConfigError, "dir_watcher_limit must be greater than zero"
+      end
+
       if !@enable_watch_timer && !@enable_stat_watcher
         raise Fluent::ConfigError, "either of enable_watch_timer or enable_stat_watcher must be true"
       end
+      raise Fluent::ConfigError, "'num_threads' must be greater than 0" unless @num_threads.positive?
+
+      if @enable_dir_watcher && !@enable_stat_watcher
+        log.info(
+          'enable_stat_watcher is disabled for files,' +
+          ' but enable_dir_watcher still uses directory stat watchers' +
+          ' and may use inotify'
+        )
+      end
 
       if @glob_policy == :always && @path_delimiter == ','
         raise Fluent::ConfigError, "cannot use glob_policy as always with the default path_delimiter: `,\""
@@ -187,11 +218,6 @@ module Fluent::Plugin
       configure_encoding
 
       @multiline_mode = parser_config["@type"].include?("multiline")
-      @receive_handler = if @multiline_mode
-                           method(:parse_multilines)
-                         else
-                           method(:parse_singleline)
-                         end
       @file_perm = system_config.file_permission || Fluent::DEFAULT_FILE_PERMISSION
       @dir_perm = system_config.dir_permission || Fluent::DEFAULT_DIR_PERMISSION
       # parser is already created by parser helper
@@ -267,6 +293,9 @@ module Fluent::Plugin
     def start
       super
 
+      @line_feeder = build_line_feeder
+      configure_worker_mode if @num_threads > 1
+
       if @pos_file
         pos_file_dir = File.dirname(@pos_file)
         FileUtils.mkdir_p(pos_file_dir, mode: @dir_perm) unless Dir.exist?(pos_file_dir)
@@ -283,7 +312,8 @@ module Fluent::Plugin
       end
 
       refresh_watchers unless @skip_refresh_on_startup
-      timer_execute(:in_tail_refresh_watchers, @refresh_interval, &method(:refresh_watchers))
+      update_dir_watchers
+      timer_execute(:in_tail_refresh_watchers, @refresh_interval, &method(:refresh_watchers_on_timer))
     end
 
     def stop
@@ -296,21 +326,39 @@ module Fluent::Plugin
 
     def shutdown
       @shutdown_start_time = Fluent::Clock.now
+      # Initial reads run as part of a refresh. Signal their timeout before
+      # waiting for the refresh, so a large file cannot delay shutdown forever.
+      (@tails.values + @tails_rotate_wait.keys).uniq.each do |tw|
+        tw.ready_to_shutdown(@shutdown_start_time)
+      end
+      # A refresh or a rotation handling may yield during file operations. Let it
+      # finish before detaching watchers or closing the position file.
+      @watcher_refresh_monitor.synchronize {}
+      # The event loop is still running at this point, so the watchers added to
+      # detect new files must be detached before the position file is closed:
+      # a change noticed by them would ask for refreshing the watchers, and
+      # #refresh_watchers writes the position file.
+      detach_dir_watchers
+      detach_refresh_timer
       # during shutdown phase, don't close io. It should be done in close after all threads are stopped. See close.
       stop_watchers(existence_path, immediate: true, remove_watcher: false)
-      @tails_rotate_wait.keys.each do |tw|
-        detach_watcher(tw, @tails_rotate_wait[tw][:ino], false)
+      @tails_rotate_wait.dup.each do |tw, rotation|
+        event_loop_detach(rotation[:timer]) if @worker_pool
+        detach_watcher(tw, rotation[:ino], false)
       end
-      @pf_file.close if @pf_file
+      shutdown_worker_pool
+      @pf_file.close if @pf_file && !@worker_pool
 
       super
     end
 
     def close
       super
+      @worker_completion_watcher&.close
       # close file handles after all threads stopped (in #close of thread plugin helper)
       # It may be because we need to wait IOHandler.ready_to_shutdown()
       close_watcher_handles
+      @pf_file.close if @pf_file && !@pf_file.closed?
     end
 
     def have_read_capability?
@@ -318,174 +366,35 @@ module Fluent::Plugin
         @capability.have_capability?(:effective, :dac_override)
     end
 
-    def extended_glob_pattern(path)
-      path.include?('*') || path.include?('?') || /\[.*\]/.match?(path)
-    end
-
-    # Curly braces is not supported with default path_delimiter
-    # because the default delimiter of path is ",".
-    # This should be collided for wildcard pattern for curly braces and
-    # be handled as an error on #configure.
-    def use_glob?(path)
-      if @glob_policy == :always
-        # For future extensions, we decided to use `always' term to handle
-        # regular expressions as much as possible.
-        # This is because not using `true' as a returning value
-        # when choosing :always here.
-        extended_glob_pattern(path) || /\{.*,.*\}/.match?(path)
-      elsif @glob_policy == :extended
-        extended_glob_pattern(path)
-      elsif @glob_policy == :backward_compatible
-        path.include?('*')
-      end
-    end
-
-    def expand_paths_raw
-      date = Fluent::EventTime.now
-      paths = []
-      @paths.each { |path|
-        path = if @path_timezone
-                 @path_formatters[path].call(date)
-               else
-                 date.to_time.strftime(path)
-               end
-        if use_glob?(path)
-          paths += Dir.glob(path).select { |p|
-            begin
-              is_file = !File.directory?(p)
-              if (File.readable?(p) || have_read_capability?) && is_file
-                if @limit_recently_modified && File.mtime(p) < (date.to_time - @limit_recently_modified)
-                  false
-                else
-                  true
-                end
-              else
-                if is_file
-                  unless @ignore_list.include?(p)
-                    log.warn "#{p} unreadable. It is excluded and would be examined next time."
-                    @ignore_list << p if @ignore_repeated_permission_error
-                  end
-                end
-                false
-              end
-            rescue Errno::ENOENT, Errno::EACCES
-              log.debug { "#{p} is missing after refresh file list" }
-              false
-            end
-          }
-        else
-          # When file is not created yet, Dir.glob returns an empty array. So just add when path is static.
-          paths << path
-        end
-      }
-      excluded = @exclude_path.map { |path|
-        path = if @path_timezone
-                 @exclude_path_formatters[path].call(date)
-               else
-                 date.to_time.strftime(path)
-               end
-        use_glob?(path) ? Dir.glob(path) : path
-      }.flatten.uniq
-      paths - excluded
-    end
-
-    def expand_paths
-      # filter out non existing files, so in case pattern is without '*' we don't do unnecessary work
-      hash = {}
-      expand_paths_raw.select { |path|
-        File.exist?(path)
-      }.each { |path|
-        # Even we just checked for existence, there is a race condition here as
-        # of which stat() might fail with ENOENT. See #3224.
-        begin
-          target_info = TargetInfo.new(path, Fluent::FileWrapper.stat(path).ino)
-          if @follow_inodes
-            hash[target_info.ino] = target_info
-          else
-            hash[target_info.path] = target_info
-          end
-        rescue Errno::ENOENT, Errno::EACCES  => e
-          log.warn "expand_paths: stat() for #{path} failed with #{e.class.name}. Skip file."
-        end
-      }
-      hash
-    end
-
-    def existence_path
-      hash = {}
-      @tails.each {|path, tw|
-        if @follow_inodes
-          hash[tw.ino] = TargetInfo.new(tw.path, tw.ino)
-        else
-          hash[tw.path] = TargetInfo.new(tw.path, tw.ino)
-        end
-      }
-      hash
-    end
-
-    # in_tail with '*' path doesn't check rotation file equality at refresh phase.
-    # So you should not use '*' path when your logs will be rotated by another tool.
-    # It will cause log duplication after updated watch files.
-    # In such case, you should separate log directory and specify two paths in path parameter.
-    # e.g. path /path/to/dir/*,/path/to/rotated_logs/target_file
-    def refresh_watchers
-      target_paths_hash = expand_paths
-      existence_paths_hash = existence_path
-
-      log.debug {
-        target_paths_str = target_paths_hash.collect { |key, target_info| target_info.path }.join(",")
-        existence_paths_str = existence_paths_hash.collect { |key, target_info| target_info.path }.join(",")
-        "tailing paths: target = #{target_paths_str} | existing = #{existence_paths_str}"
-      }
-
-      if !@follow_inodes
-        need_unwatch_in_stop_watchers = true
-      else
-        # When using @follow_inodes, need this to unwatch the rotated old inode when it disappears.
-        # After `update_watcher` detaches an old TailWatcher, the inode is lost from the `@tails`.
-        # So that inode can't be contained in `removed_hash`, and can't be unwatched by `stop_watchers`.
-        #
-        # This logic may work for `@follow_inodes false` too.
-        # Just limiting the case to suppress the impact to existing logics.
-        @pf&.unwatch_removed_targets(target_paths_hash)
-        need_unwatch_in_stop_watchers = false
-      end
-
-      removed_hash = existence_paths_hash.reject {|key, value| target_paths_hash.key?(key)}
-      added_hash = target_paths_hash.reject {|key, value| existence_paths_hash.key?(key)}
-
-      # If an existing TailWatcher already follows a target path with the different inode,
-      # it means that the TailWatcher following the rotated file still exists. In this case,
-      # `refresh_watcher` can't start the new TailWatcher for the new current file. So, we
-      # should output a warning log in order to prevent silent collection stops.
-      # (Such as https://github.com/fluent/fluentd/pull/4327)
-      # (Usually, such a TailWatcher should be removed from `@tails` in `update_watcher`.)
-      # (The similar warning may work for `@follow_inodes true` too. Just limiting the case
-      # to suppress the impact to existing logics.)
-      unless @follow_inodes
-        target_paths_hash.each do |path, target|
-          next unless @tails.key?(path)
-          # We can't use `existence_paths_hash[path].ino` because it is from `TailWatcher.ino`,
-          # which is very unstable parameter. (It can be `nil` or old).
-          # So, we need to use `TailWatcher.pe.read_inode`.
-          existing_watcher_inode = @tails[path].pe.read_inode
-          if existing_watcher_inode != target.ino
-            log.warn "Could not follow a file (inode: #{target.ino}) because an existing watcher for that filepath follows a different inode: #{existing_watcher_inode} (e.g. keeps watching a already rotated file). If you keep getting this message, please restart Fluentd.",
-              filepath: target.path
-          end
-        end
-      end
-
-      stop_watchers(removed_hash, unwatched: need_unwatch_in_stop_watchers) unless removed_hash.empty?
-      start_watchers(added_hash) unless added_hash.empty?
-      @metrics.tracked.set(@tails.size)
-      @startup = false if @startup
+    # TailInput builds its LineFeeder in start, after the configure of a plugin
+    # which inherits TailInput is done, so that the parameters set by that
+    # plugin are used.
+    def build_line_feeder
+      LineFeeder.new(
+        parser: @parser,
+        router_provider: method(:router),
+        log: log,
+        tag: @tag,
+        tag_prefix: @tag_prefix,
+        tag_suffix: @tag_suffix,
+        path_key: @path_key,
+        emit_unmatched_lines: @emit_unmatched_lines,
+        multiline_mode: @multiline_mode,
+        parse_handler: method(@multiline_mode ? :parse_multilines : :parse_singleline),
+        convert_handler: method(:convert_line_to_event),
+        flush_handler: method(:flush_buffer),
+      )
     end
 
     def setup_watcher(target_info, pe)
-      line_buffer_timer_flusher = @multiline_mode ? TailWatcher::LineBufferTimerFlusher.new(log, @multiline_flush_interval, &method(:flush_buffer)) : nil
+      # A plugin may build a watcher before start. The LineFeeder of that
+      # moment has the same parameters, because the configure of every plugin
+      # is done before the watchers are built.
+      @line_feeder ||= build_line_feeder
+      file_feed = @line_feeder.new_file_feed(flush_interval: @multiline_flush_interval)
       read_from_head = !@startup || @read_from_head
-      tw = TailWatcher.new(target_info, pe, log, read_from_head, @follow_inodes, method(:update_watcher), line_buffer_timer_flusher, method(:io_handler), @metrics)
+      tw = TailWatcher.new(target_info, pe, log, read_from_head, @follow_inodes, method(:update_watcher), file_feed, method(:io_handler), @metrics)
+      tw.ready_to_shutdown(@shutdown_start_time) if @shutdown_start_time
 
       if @enable_watch_timer
         tt = TimerTrigger.new(1, log) { tw.on_notify }
@@ -501,7 +410,7 @@ module Fluent::Plugin
         event_loop_attach(watcher)
       end
 
-      tw.group_watcher = add_path_to_group_watcher(target_info.path)
+      tw.group_watcher = add_path_to_group_watcher(target_info.path, tw)
 
       tw
     rescue => e
@@ -541,6 +450,7 @@ module Fluent::Plugin
       end
 
       @tails[path] = tw
+      tw.ready_to_shutdown(@shutdown_start_time) if @shutdown_start_time
       tw.on_notify
     end
 
@@ -553,8 +463,6 @@ module Fluent::Plugin
 
     def stop_watchers(targets_info, immediate: false, unwatched: false, remove_watcher: true)
       targets_info.each_value { |target_info|
-        remove_path_from_group_watcher(target_info.path)
-
         if remove_watcher
           tw = @tails.delete(target_info.path)
         else
@@ -572,6 +480,11 @@ module Fluent::Plugin
     end
 
     def close_watcher_handles
+      if @worker_pool
+        close_worker_watcher_handles
+        return
+      end
+
       @tails.keys.each do |path|
         tw = @tails.delete(path)
         if tw
@@ -583,22 +496,22 @@ module Fluent::Plugin
       end
     end
 
-    # refresh_watchers calls @tails.keys so we don't use stop_watcher -> start_watcher sequence for safety.
     def update_watcher(tail_watcher, pe, new_inode)
+      @watcher_refresh_monitor.synchronize do
+        return if @shutdown_start_time
+
+        update_watcher_raw(tail_watcher, pe, new_inode)
+      end
+    end
+
+    # refresh_watchers calls @tails.keys so we don't use stop_watcher -> start_watcher sequence for safety.
+    def update_watcher_raw(tail_watcher, pe, new_inode)
       # TODO we should use another callback for this.
       # To suppress impact to existing logics, limit the case to `@follow_inodes`.
       # We may not need `@follow_inodes` condition.
       if @follow_inodes && new_inode.nil?
         # nil inode means the file disappeared, so we only need to stop it.
         @tails.delete(tail_watcher.path)
-        # https://github.com/fluent/fluentd/pull/4237#issuecomment-1633358632
-        # Because of this problem, log duplication can occur during `rotate_wait`.
-        # Need to set `rotate_wait 0` for a workaround.
-        # Duplication will occur if `refresh_watcher` is called during the `rotate_wait`.
-        # In that case, `refresh_watcher` will add the new TailWatcher to tail the same target,
-        # and it causes the log duplication.
-        # (Other `detach_watcher_after_rotate_wait` may have the same problem.
-        #  We need the mechanism not to add duplicated TailWatcher with detaching TailWatcher.)
         detach_watcher_after_rotate_wait(tail_watcher, pe.read_inode)
         return
       end
@@ -625,10 +538,12 @@ module Fluent::Plugin
         # In this case, only we have to do is detaching the current tail_watcher.
         if new_position_entry.read_inode == 0
           @tails[path] = setup_watcher(new_target_info, new_position_entry)
+          @tails[path].ready_to_shutdown(@shutdown_start_time) if @shutdown_start_time
           @tails[path].on_notify
         end
       else
         @tails[path] = setup_watcher(new_target_info, pe)
+        @tails[path].ready_to_shutdown(@shutdown_start_time) if @shutdown_start_time
         @tails[path].on_notify
       end
 
@@ -645,11 +560,24 @@ module Fluent::Plugin
       end
       tw.detach(@shutdown_start_time)
 
+      # The final read in detach may itself submit a worker batch.
+      defer_worker_completion = tw.pending? || @worker_waiting_watchers&.include?(tw)
+      if close_io && defer_worker_completion
+        tw.defer_close
+        @worker_detached_watchers << tw unless @worker_detached_watchers.include?(tw)
+      end
       tw.close if close_io
 
-      if @pf && tw.unwatched && (@follow_inode || !@tails[tw.path])
+      # A watcher waiting for `rotate_wait` cannot read once its path leaves the group watcher.
+      tw.group_watcher&.delete(tw.path, tw)
+
+      if @pf && tw.unwatched && (@follow_inodes || !@tails[tw.path])
         target_info = TargetInfo.new(tw.path, ino)
-        @pf.unwatch(target_info)
+        if defer_worker_completion
+          @worker_deferred_unwatch[tw] = target_info
+        else
+          @pf.unwatch(target_info)
+        end
       end
     end
 
@@ -665,6 +593,7 @@ module Fluent::Plugin
       if @open_on_every_update
         # Detach now because it's already closed, waiting it doesn't make sense.
         detach_watcher(tw, ino)
+        return
       end
 
       return if @tails_rotate_wait[tw]
@@ -674,6 +603,15 @@ module Fluent::Plugin
         # Should ensure to read all contents before closing it, with keeping throttling.
         start_time_to_wait = Fluent::Clock.now
         timer = timer_execute(:in_tail_close_watcher, 1, repeat: true) do
+          # Without the watch timer, nothing else notifies a watcher whose path has been rotated away.
+          unless @enable_watch_timer
+            begin
+              tw.read_more
+            rescue => e
+              log.error e.to_s
+              log.error_backtrace
+            end
+          end
           elapsed = Fluent::Clock.now - start_time_to_wait
           if tw.eof? && elapsed >= @rotate_wait
             timer.detach
@@ -692,124 +630,6 @@ module Fluent::Plugin
       end
     end
 
-    def flush_buffer(tw, buf)
-      buf.chomp!
-      @parser.parse(buf) { |time, record|
-        if time && record
-          tag = if @tag_prefix || @tag_suffix
-                  @tag_prefix + tw.tag + @tag_suffix
-                else
-                  @tag
-                end
-          record[@path_key] ||= tw.path unless @path_key.nil?
-          router.emit(tag, time, record)
-        else
-          if @emit_unmatched_lines
-            record = { 'unmatched_line' => buf }
-            record[@path_key] ||= tail_watcher.path unless @path_key.nil?
-            tag = if @tag_prefix || @tag_suffix
-                    @tag_prefix + tw.tag + @tag_suffix
-                  else
-                    @tag
-                  end
-            router.emit(tag, Fluent::EventTime.now, record)
-          end
-          log.warn "got incomplete line at shutdown from #{tw.path}: #{buf.inspect}"
-        end
-      }
-    end
-
-    # @return true if no error or unrecoverable error happens in emit action. false if got BufferOverflowError
-    def receive_lines(lines, tail_watcher)
-      es = @receive_handler.call(lines, tail_watcher)
-      unless es.empty?
-        tag = if @tag_prefix || @tag_suffix
-                @tag_prefix + tail_watcher.tag + @tag_suffix
-              else
-                @tag
-              end
-        begin
-          router.emit_stream(tag, es)
-        rescue Fluent::Plugin::Buffer::BufferOverflowError
-          return false
-        rescue
-          # ignore non BufferQueueLimitError errors because in_tail can't recover. Engine shows logs and backtraces.
-          return true
-        end
-      end
-
-      return true
-    end
-
-    def convert_line_to_event(line, es, tail_watcher)
-      begin
-        line.chomp!  # remove \n
-        @parser.parse(line) { |time, record|
-          if time && record
-            record[@path_key] ||= tail_watcher.path unless @path_key.nil?
-            es.add(time, record)
-          else
-            if @emit_unmatched_lines
-              record = {'unmatched_line' => line}
-              record[@path_key] ||= tail_watcher.path unless @path_key.nil?
-              es.add(Fluent::EventTime.now, record)
-            end
-            log.warn { "pattern not matched: #{line.inspect}" }
-          end
-        }
-      rescue => e
-        log.warn 'invalid line found', file: tail_watcher.path, line: line, error: e.to_s
-        log.debug_backtrace(e.backtrace)
-      end
-    end
-
-    def parse_singleline(lines, tail_watcher)
-      es = Fluent::MultiEventStream.new
-      lines.each { |line|
-        convert_line_to_event(line, es, tail_watcher)
-      }
-      es
-    end
-
-    # No need to check if line_buffer_timer_flusher is nil, since line_buffer_timer_flusher should exist
-    def parse_multilines(lines, tail_watcher)
-      lb = tail_watcher.line_buffer_timer_flusher.line_buffer
-      es = Fluent::MultiEventStream.new
-      if @parser.has_firstline?
-        tail_watcher.line_buffer_timer_flusher.reset_timer
-        lines.each { |line|
-          if @parser.firstline?(line)
-            if lb
-              convert_line_to_event(lb, es, tail_watcher)
-            end
-            lb = line
-          else
-            if lb.nil?
-              if @emit_unmatched_lines
-                convert_line_to_event(line, es, tail_watcher)
-              end
-              log.warn "got incomplete line before first line from #{tail_watcher.path}: #{line.inspect}"
-            else
-              lb << line
-            end
-          end
-        }
-      else
-        lb ||= ''
-        lines.each do |line|
-          lb << line
-          @parser.parse(lb) { |time, record|
-            if time && record
-              convert_line_to_event(lb, es, tail_watcher)
-              lb = ''
-            end
-          }
-        end
-      end
-      tail_watcher.line_buffer_timer_flusher.line_buffer = lb
-      es
-    end
-
     def statistics
       stats = super
 
@@ -822,6 +642,13 @@ module Fluent::Plugin
           'tracked_file_count' => @metrics.tracked.get,
         })
       }
+      if @worker_pool
+        stats['input'].merge!(
+          'worker_pending_batch_count' => @worker_metrics[:pending_batches].get,
+          'worker_pending_bytes' => @worker_metrics[:pending_bytes].get,
+          'worker_parse_error_count' => @worker_metrics[:parse_errors].get,
+        )
+      end
       stats
     end
 
@@ -852,556 +679,238 @@ module Fluent::Plugin
         &method(:receive_lines)
       )
     end
+  end
 
-    class StatWatcher < Coolio::StatWatcher
-      def initialize(path, log, &callback)
-        @callback = callback
-        @log = log
-        super(path)
-      end
+  # Reopen TailInput to keep worker-mode setup and lifecycle helpers grouped
+  # separately from the synchronous file-watching implementation above.
+  class TailInput
+    WORKER_COMPATIBILITY = WorkerCompatibility.new(self)
+    WORKER_PARSER_TYPES = %w[
+      none regexp json csv tsv ltsv msgpack apache apache2 apache_error nginx syslog
+    ].freeze
+    WORKER_QUEUE_BYTES = 64 * 1024 * 1024
+    WorkerBatch = Struct.new(:watcher, :lines)
 
-      def on_change(prev, cur)
-        @callback.call
-      rescue
-        @log.error $!.to_s
-        @log.error_backtrace
-      end
-    end
-
-    class TimerTrigger < Coolio::TimerWatcher
-      def initialize(interval, log, &callback)
-        @log = log
-        @callback = callback
-        super(interval, true)
-      end
+    private
 
-      def on_timer
-        @callback.call
-      rescue => e
-        @log.error e.to_s
-        @log.error_backtrace
+    def configure_worker_mode
+      incompatibility_reasons = worker_incompatibility_reasons
+      @worker_compatible = incompatibility_reasons.empty?
+      if @worker_compatible
+        setup_worker_pool
+        log.info "in_tail worker parsing enabled with #{@num_threads} threads"
+      else
+        log.warn "in_tail worker parsing is unavailable; using synchronous parsing (#{incompatibility_reasons.join(', ')})"
       end
     end
 
-    class TailWatcher
-      def initialize(target_info, pe, log, read_from_head, follow_inodes, update_watcher, line_buffer_timer_flusher, io_handler_build, metrics)
-        @path = target_info.path
-        @ino = target_info.ino
-        @pe = pe || MemoryPositionEntry.new
-        @read_from_head = read_from_head
-        @follow_inodes = follow_inodes
-        @update_watcher = update_watcher
-        @log = log
-        @rotate_handler = RotateHandler.new(log, &method(:on_rotate))
-        @line_buffer_timer_flusher = line_buffer_timer_flusher
-        @io_handler = nil
-        @io_handler_build = io_handler_build
-        @metrics = metrics
-        @watchers = []
-      end
+    def worker_incompatibility_reasons
+      reasons = WORKER_COMPATIBILITY.incompatible_hooks(self).map { |hook| "overridden hook: #{hook}" }
+      reasons << 'multiline parsing is enabled' if @multiline_mode
+      reasons << 'open_on_every_update is enabled' if @open_on_every_update
+      parser_type = @parser_configs.first[:@type]
+      reasons << "unsupported parser: #{parser_type}" unless WORKER_PARSER_TYPES.include?(parser_type)
+      parser_usage = @parser_configs.first.usage
+      reasons << 'the configured parser instance was replaced' unless @parser.equal?(@_parsers[parser_usage])
+      reasons
+    end
 
-      attr_reader :path, :ino
-      attr_reader :pe
-      attr_reader :line_buffer_timer_flusher
-      attr_accessor :unwatched  # This is used for removing position entry from PositionFile
-      attr_reader :watchers
-      attr_accessor :group_watcher
+    def create_worker_parsers(num_threads)
+      return [] unless @worker_compatible
+      raise ArgumentError, 'worker count must be positive' unless num_threads.positive?
 
-      def tag
-        @parsed_tag ||= @path.tr('/', '.').squeeze('.').gsub(/^\./, '')
+      parser_config = @parser_configs.first.corresponding_config_element
+      Array.new(num_threads) do |index|
+        usage = "__in_tail_worker_#{object_id}_#{index}"
+        parser_create(usage: usage, conf: parser_config)
       end
+    end
 
-      def register_watcher(watcher)
-        @watchers << watcher
-      end
+    def setup_worker_pool
+      @worker_metrics = {
+        pending_batches: metrics_create(namespace: 'fluentd', subsystem: 'input', name: 'worker_pending_batches',
+                                        help_text: 'Number of worker batches awaiting completion or acknowledgment',
+                                        prefer_gauge: true),
+        pending_bytes: metrics_create(namespace: 'fluentd', subsystem: 'input', name: 'worker_pending_bytes',
+                                       help_text: 'Estimated bytes accounted for by pending worker batches',
+                                       prefer_gauge: true),
+        parse_errors: metrics_create(namespace: 'fluentd', subsystem: 'input', name: 'worker_parse_errors_total',
+                                     help_text: 'Total number of worker parse errors'),
+      }
+      @worker_parsers = create_worker_parsers(@num_threads)
+      @worker_line_feeders = @worker_parsers.map { |parser| build_worker_line_feeder(parser) }
+      @worker_waiting_watchers = []
+      @worker_deferred_unwatch = {}
+      @worker_detached_watchers = []
+      @worker_completion_mutex = Mutex.new
+      @worker_completions_stopped = false
+      @worker_completion_watcher = WorkerCompletionWatcher.new(log: log) { process_worker_completions }
+      event_loop_attach(@worker_completion_watcher)
+      @worker_pool = WorkerPool.new(
+        num_threads: @num_threads,
+        task_limit: @num_threads * 2,
+        byte_limit: WORKER_QUEUE_BYTES,
+        thread_create: ->(title, &block) { Thread.new { Thread.current.name = title.to_s if Thread.current.respond_to?(:name=); block.call } },
+        notify: @worker_completion_watcher.method(:signal)
+      ) do |index, batch|
+        @worker_line_feeders[index].parse(batch.lines.map(&:dup), batch.watcher)
+      end
+      @worker_pool.start
+    rescue
+      event_loop_detach(@worker_completion_watcher) if @worker_completion_watcher&.attached?
+      @worker_completion_watcher&.close
+      raise
+    end
+
+    def build_worker_line_feeder(parser)
+      LineFeeder.new(
+        parser: parser,
+        router_provider: method(:router),
+        log: log,
+        tag: @tag,
+        tag_prefix: @tag_prefix,
+        tag_suffix: @tag_suffix,
+        path_key: @path_key,
+        emit_unmatched_lines: @emit_unmatched_lines,
+        multiline_mode: false
+      )
+    end
 
-      def detach(shutdown_start_time = nil)
-        if @io_handler
-          @io_handler.ready_to_shutdown(shutdown_start_time)
-          @io_handler.on_notify
-        end
-        @line_buffer_timer_flusher&.close(self)
-      end
+    def async_receive_lines(lines, watcher)
+      return @line_feeder.feed_lines(lines, watcher) unless @worker_pool.statistics[:state] == :running
 
-      def close
-        if @io_handler
-          @io_handler.close
-          @io_handler = nil
-        end
+      bytes = lines.sum(&:bytesize) * 3
+      batch = WorkerBatch.new(watcher, lines)
+      if @worker_pool.submit(watcher, batch, bytes: bytes)
+        update_worker_metrics
+        @worker_waiting_watchers.delete(watcher)
+        TailWatcher::IOHandler::ASYNC_PENDING
+      else
+        @worker_waiting_watchers << watcher unless @worker_waiting_watchers.include?(watcher)
+        false
       end
+    end
 
-      def eof?
-        @io_handler.nil? || @io_handler.eof?
+    def process_worker_completions
+      @worker_completion_mutex.synchronize do
+        drain_worker_completions(resume: true) unless @worker_completions_stopped
       end
+    end
 
-      def on_notify
+    def drain_worker_completions(resume:)
+      while (result = @worker_pool.next_result)
         begin
-          stat = Fluent::FileWrapper.stat(@path)
-        rescue Errno::ENOENT, Errno::EACCES
-          # moved or deleted
-          stat = nil
+          complete_worker_result(result, resume: resume)
+        rescue => error
+          log.error 'unexpected error while completing in_tail worker batch', error: error
+          log.error_backtrace
         end
-
-        @rotate_handler.on_notify(stat) if @rotate_handler
-        @line_buffer_timer_flusher.on_notify(self) if @line_buffer_timer_flusher
-        @io_handler.on_notify if @io_handler
       end
 
-      def on_rotate(stat)
-        if @io_handler.nil?
-          if stat
-            # first time
-            fsize = stat.size
-            inode = stat.ino
-
-            last_inode = @pe.read_inode
-            if inode == last_inode
-              # rotated file has the same inode number with the last file.
-              # assuming following situation:
-              #   a) file was once renamed and backed, or
-              #   b) symlink or hardlink to the same file is recreated
-              # in either case of a and b, seek to the saved position
-              #   c) file was once renamed, truncated and then backed
-              # in this case, consider it truncated
-              @pe.update(inode, 0) if fsize < @pe.read_pos
-            elsif last_inode != 0
-              # this is FilePositionEntry and fluentd once started.
-              # read data from the head of the rotated file.
-              # logs never duplicate because this file is a rotated new file.
-              @pe.update(inode, 0)
-            else
-              # this is MemoryPositionEntry or this is the first time fluentd started.
-              # seek to the end of the any files.
-              # logs may duplicate without this seek because it's not sure the file is
-              # existent file or rotated new file.
-              pos = @read_from_head ? 0 : fsize
-              @pe.update(inode, pos)
-            end
-            @io_handler = io_handler
-          else
-            @io_handler = NullIOHandler.new
-          end
-        else
-          watcher_needs_update = false
-
-          if stat
-            inode = stat.ino
-            if inode == @pe.read_inode # truncated
-              @pe.update_pos(0)
-              @io_handler.close
-            elsif !@io_handler.opened? # There is no previous file. Reuse TailWatcher
-              @pe.update(inode, 0)
-            else # file is rotated and new file found
-              watcher_needs_update = true
-              # Handle the old log file before renewing TailWatcher [fluentd#1055]
-              @io_handler.on_notify
-            end
-          else # file is rotated and new file not found
-            # Clear RotateHandler to avoid duplicated file watch in same path.
-            @rotate_handler = nil
-            watcher_needs_update = true
-          end
+      return unless resume
 
-          if watcher_needs_update
-            if @follow_inodes
-              # If stat is nil (file not present), NEED to stop and discard this watcher.
-              #   When the file is disappeared but is resurrected soon, then `#refresh_watcher`
-              #   can't recognize this TailWatcher needs to be stopped.
-              #   This can happens when the file is rotated.
-              #   If a notify comes before the new file for the path is created during rotation,
-              #   then it appears as if the file was resurrected once it disappeared.
-              # Don't want to swap state because we need latest read offset in pos file even after rotate_wait
-              @update_watcher.call(self, @pe, stat&.ino)
-            else
-              # Permit to handle if stat is nil (file not present).
-              # If a file is mv-ed and a new file is created during
-              # calling `#refresh_watchers`s, and `#refresh_watchers` won't run `#start_watchers`
-              # and `#stop_watchers()` for the path because `target_paths_hash`
-              # always contains the path.
-              @update_watcher.call(self, swap_state(@pe), stat&.ino)
-            end
-          else
-            @log.info "detected rotation of #{@path}"
-            @io_handler = io_handler
-          end
-          @metrics.rotated.inc
+      waiting = @worker_waiting_watchers
+      @worker_waiting_watchers = []
+      waiting.each do |watcher|
+        begin
+          watcher.detached? ? watcher.read_more : watcher.on_notify
+        rescue => error
+          log.error 'unexpected error while retrying in_tail worker batch', error: error
+          log.error_backtrace
+        ensure
+          finish_worker_deferred_close(watcher)
         end
       end
+    end
 
-      def io_handler
-        @io_handler_build.call(self, @path)
-      end
-
-      def swap_state(pe)
-        # Use MemoryPositionEntry for rotated file temporary
-        mpe = MemoryPositionEntry.new
-        mpe.update(pe.read_inode, pe.read_pos)
-        @pe = mpe
-        pe # This pe will be updated in on_rotate after TailWatcher is initialized
-      end
-
-      class FIFO
-        def initialize(encoding, log, max_line_size=nil, encoding_to_convert=nil)
-          @buffer = ''.force_encoding(encoding)
-          @eol = "\n".encode(encoding).freeze
-          @encoding_to_convert = encoding_to_convert
-          @max_line_size = max_line_size
-          @skip_current_line = false
-          @skipping_current_line_bytesize = 0
-          @log = log
-        end
-
-        attr_reader :buffer, :max_line_size
-
-        def <<(chunk)
-          @buffer << chunk
-        end
-
-        def convert(s)
-          if @encoding_to_convert
-            s.encode!(@encoding_to_convert)
+    def complete_worker_result(result, resume:)
+      batch = result.task.payload
+      emitted = false
+      begin
+        if result.error
+          @worker_metrics[:parse_errors].inc
+          if resume
+            log.warn 'worker parsing failed; retrying synchronously', path: batch.watcher.path, error: result.error
+            emitted = @line_feeder.feed_lines(batch.lines, batch.watcher)
           else
-            s
+            log.warn 'worker parsing failed during shutdown; leaving position unchanged', path: batch.watcher.path, error: result.error
           end
-        rescue
-          s.encode!(@encoding_to_convert, :invalid => :replace, :undef => :replace)
+        else
+          emitted = @line_feeder.emit(result.value, batch.watcher)
         end
-
-        def read_lines(lines)
-          idx = @buffer.index(@eol)
-          has_skipped_line = false
-
-          until idx.nil?
-            # Using freeze and slice is faster than slice!
-            # See https://github.com/fluent/fluentd/pull/2527
-            @buffer.freeze
-            slice_position = idx + 1
-            rbuf = @buffer.slice(0, slice_position)
-            @buffer = @buffer.slice(slice_position, @buffer.size - slice_position)
-            idx = @buffer.index(@eol)
-
-            is_long_line = @max_line_size && (
-              @skip_current_line || rbuf.bytesize > @max_line_size
-            )
-
-            if is_long_line
-              @log.warn "received line length is longer than #{@max_line_size}"
-              if @skip_current_line
-                @log.debug("The continuing line is finished. Finally discarded data: ") { convert(rbuf).chomp }
-              else
-                @log.debug("skipped line: ") { convert(rbuf).chomp }
-              end
-              has_skipped_line = true
-              @skip_current_line = false
-              @skipping_current_line_bytesize = 0
-              next
-            end
-
-            lines << convert(rbuf)
-          end
-
-          is_long_current_line = @max_line_size && (
-            @skip_current_line || @buffer.bytesize > @max_line_size
-          )
-
-          if is_long_current_line
-            @log.debug(
-              "The continuing current line length is longer than #{@max_line_size}." +
-              " The received data will be discarded until this line is finished." +
-              " Discarded data: "
-            ) { convert(@buffer).chomp }
-            @skip_current_line = true
-            @skipping_current_line_bytesize += @buffer.bytesize
-            @buffer.clear
+      ensure
+        begin
+          @worker_pool.acknowledge(result)
+          update_worker_metrics
+        ensure
+          begin
+            batch.watcher.complete_async(emitted, resume: resume)
+          ensure
+            finish_worker_deferred_close(batch.watcher)
           end
-
-          return has_skipped_line
-        end
-
-        def reading_bytesize
-          return @skipping_current_line_bytesize if @skip_current_line
-          @buffer.bytesize
         end
       end
+    end
 
-      class IOHandler
-        BYTES_TO_READ = 8192
-        SHUTDOWN_TIMEOUT = 5
-
-        attr_accessor :shutdown_timeout
-
-        def initialize(watcher, path:, read_lines_limit:, read_bytes_limit_per_second:, max_line_size: nil, log:, open_on_every_update:, encoding: Encoding::ASCII_8BIT, encoding_to_convert: nil, metrics:, &receive_lines)
-          @watcher = watcher
-          @path = path
-          @read_lines_limit = read_lines_limit
-          @read_bytes_limit_per_second = read_bytes_limit_per_second
-          @receive_lines = receive_lines
-          @open_on_every_update = open_on_every_update
-          @encoding = encoding
-          @fifo = FIFO.new(encoding, log, max_line_size, encoding_to_convert)
-          @lines = []
-          @io = nil
-          @notify_mutex = Mutex.new
-          @log = log
-          @start_reading_time = nil
-          @number_bytes_read = 0
-          @shutdown_start_time = nil
-          @shutdown_timeout = SHUTDOWN_TIMEOUT
-          @shutdown_mutex = Mutex.new
-          @eof = false
-          @metrics = metrics
-
-          @log.info "following tail of #{@path}"
-        end
-
-        def group_watcher
-          @watcher.group_watcher
-        end
-
-        def on_notify
-          @notify_mutex.synchronize { handle_notify }
-        end
-
-        def ready_to_shutdown(shutdown_start_time = nil)
-          @shutdown_mutex.synchronize {
-            @shutdown_start_time =
-              shutdown_start_time || Fluent::Clock.now
-          }
-        end
-
-        def close
-          if @io && !@io.closed?
-            @io.close
-            @io = nil
-            @metrics.closed.inc
-          end
-        end
-
-        def opened?
-          !!@io
-        end
-
-        def eof?
-          @eof
-        end
-
-        private
-
-        def limit_bytes_per_second_reached?
-          return false if @read_bytes_limit_per_second < 0 # not enabled by conf
-          return false if @number_bytes_read < @read_bytes_limit_per_second
-
-          @start_reading_time ||= Fluent::Clock.now
-          time_spent_reading = Fluent::Clock.now - @start_reading_time
-          @log.debug("time_spent_reading: #{time_spent_reading} #{ @watcher.path}")
-
-          if time_spent_reading < 1
-            true
-          else
-            @start_reading_time = nil
-            @number_bytes_read = 0
-            false
-          end
-        end
-
-        def should_shutdown_now?
-          # Ensure to read all remaining lines, but abort immediately if it
-          # seems to take too long time.
-          @shutdown_mutex.synchronize {
-            return false if @shutdown_start_time.nil?
-            return Fluent::Clock.now - @shutdown_start_time > @shutdown_timeout
-          }
-        end
+    def finish_worker_deferred_close(watcher)
+      return if watcher.pending? || @worker_waiting_watchers.include?(watcher)
 
-        def handle_notify
-          if limit_bytes_per_second_reached? || group_watcher&.limit_lines_reached?(@path)
-            @metrics.throttled.inc
-            return
-          end
+      # Match synchronous detach on failed emit or a throttled final read:
+      # close the handle, leaving uncommitted data for a future watch.
+      watcher.close_if_ready(force: watcher.detached?)
+      @worker_detached_watchers.delete(watcher)
 
-          with_io do |io|
-            iobuf = ''.force_encoding(@encoding)
-            begin
-              read_more = false
-              has_skipped_line = false
-
-              if !io.nil? && @lines.empty?
-                begin
-                  while true
-                    @start_reading_time ||= Fluent::Clock.now
-                    group_watcher&.update_reading_time(@path)
-
-                    data = io.readpartial(BYTES_TO_READ, iobuf)
-                    @eof = false
-                    @number_bytes_read += data.bytesize
-                    @fifo << data
-
-                    n_lines_before_read = @lines.size
-                    has_skipped_line = @fifo.read_lines(@lines) || has_skipped_line
-                    group_watcher&.update_lines_read(@path, @lines.size - n_lines_before_read)
-
-                    group_watcher_limit = group_watcher&.limit_lines_reached?(@path)
-                    @log.debug "Reading Limit exceeded #{@path} #{group_watcher.number_lines_read}" if group_watcher_limit
-
-                    if group_watcher_limit || limit_bytes_per_second_reached? || should_shutdown_now?
-                      # Just get out from tailing loop.
-                      @metrics.throttled.inc if group_watcher_limit || limit_bytes_per_second_reached?
-                      read_more = false
-                      break
-                    end
-
-                    if @lines.size >= @read_lines_limit
-                      # not to use too much memory in case the file is very large
-                      read_more = true
-                      break
-                    end
-                  end
-                rescue EOFError
-                  @eof = true
-                ensure
-                  iobuf.clear
-                end
-              end
-
-              if @lines.empty?
-                @watcher.pe.update_pos(io.pos - @fifo.reading_bytesize) if has_skipped_line
-              else
-                if @receive_lines.call(@lines, @watcher)
-                  @watcher.pe.update_pos(io.pos - @fifo.reading_bytesize)
-                  @lines.clear
-                else
-                  read_more = false
-                end
-              end
-            end while read_more
-          end
-        end
+      target_info = @worker_deferred_unwatch.delete(watcher)
+      @pf.unwatch(target_info) if target_info && @pf
+    end
 
-        def open
-          io = Fluent::FileWrapper.open(@path)
-          io.seek(@watcher.pe.read_pos + @fifo.reading_bytesize)
-          @metrics.opened.inc
-          io
-        rescue RangeError
-          io.close if io
-          raise WatcherSetupError, "seek error with #{@path}: file position = #{@watcher.pe.read_pos.to_s(16)}, reading bytesize = #{@fifo.reading_bytesize.to_s(16)}"
-        rescue Errno::EACCES => e
-          @log.warn "#{e}"
-          nil
-        rescue Errno::ENOENT
-          nil
-        end
+    def update_worker_metrics
+      statistics = @worker_pool.statistics
+      @worker_metrics[:pending_batches].set(statistics[:tasks])
+      @worker_metrics[:pending_bytes].set(statistics[:bytes])
+    end
 
-        def with_io
-          if @open_on_every_update
-            io = open
-            begin
-              yield io
-            ensure
-              io.close unless io.nil?
-            end
-          else
-            @io ||= open
-            yield @io
-            @eof = true if @io.nil?
-          end
-        rescue WatcherSetupError => e
-          close
-          @eof = true
-          raise e
-        rescue
-          @log.error $!.to_s
-          @log.error_backtrace
-          close
-          @eof = true
-        end
+    def close_worker_watcher_handles
+      watchers = (@tails.values + @tails_rotate_wait.keys + @worker_detached_watchers + @worker_deferred_unwatch.keys).uniq
+      watchers.each(&:force_close)
+      @tails.clear
+      @worker_detached_watchers.clear
+      @worker_deferred_unwatch.each_value do |target_info|
+        @pf.unwatch(target_info) if @pf
       end
+      @worker_deferred_unwatch.clear
+    end
 
-      class NullIOHandler
-        def initialize
-        end
-
-        def io
-        end
-
-        def on_notify
-        end
-
-        def close
-        end
+    def shutdown_worker_pool
+      return unless @worker_pool
 
-        def opened?
-          false
-        end
-
-        def eof?
-          true
-        end
+      deadline = Fluent::Clock.now + TailWatcher::IOHandler::SHUTDOWN_TIMEOUT
+      while worker_work_pending?
+        break if Fluent::Clock.now >= deadline
+        sleep 0.01
       end
-
-      class RotateHandler
-        def initialize(log, &on_rotate)
-          @log = log
-          @inode = nil
-          @fsize = -1  # first
-          @on_rotate = on_rotate
-        end
-
-        def on_notify(stat)
-          if stat.nil?
-            inode = nil
-            fsize = 0
-          else
-            inode = stat.ino
-            fsize = stat.size
-          end
-
-          if @inode != inode || fsize < @fsize
-            @on_rotate.call(stat)
-          end
-          @inode = inode
-          @fsize = fsize
-        rescue
-          @log.error $!.to_s
-          @log.error_backtrace
-        end
+      if worker_work_pending?
+        log.warn 'in_tail worker pool did not drain before shutdown timeout'
       end
+      event_loop_detach(@worker_completion_watcher)
+      # Detach alone does not wait for a callback already running. Serialize
+      # the handover so every result is handled before output shutdown starts.
+      @worker_completion_mutex.synchronize do
+        @worker_completions_stopped = true
+        @worker_pool.stop
+      end
+      unless @worker_pool.join(timeout: TailWatcher::IOHandler::SHUTDOWN_TIMEOUT)
+        log.warn 'in_tail worker threads did not stop before timeout'
+        @worker_pool.kill
+      end
+      @worker_completion_mutex.synchronize do
+        drain_worker_completions(resume: false)
+      end
+    end
 
-      class LineBufferTimerFlusher
-        attr_accessor :line_buffer
-
-        def initialize(log, flush_interval, &flush_method)
-          @log = log
-          @flush_interval = flush_interval
-          @flush_method = flush_method
-          @start = nil
-          @line_buffer = nil
-        end
-
-        def on_notify(tw)
-          unless @start && @flush_method
-            return
-          end
-
-          if Time.now - @start >= @flush_interval
-            @flush_method.call(tw, @line_buffer) if @line_buffer
-            @line_buffer = nil
-            @start = nil
-          end
-        end
-
-        def close(tw)
-          return unless @line_buffer
-
-          @flush_method.call(tw, @line_buffer)
-          @line_buffer = nil
-        end
-
-        def reset_timer
-          return unless @flush_interval
-
-          @start = Time.now
-        end
+    def worker_work_pending?
+      @worker_completion_mutex.synchronize do
+        @worker_pool.statistics[:tasks].positive? || !@worker_waiting_watchers.empty?
       end
     end
   end