fluentd 1.14.6-x86-mingw32 → 1.15.2-x86-mingw32

data/lib/fluent/plugin/in_tail.rb

@@ -24,6 +24,7 @@ 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'
 
 if Fluent.windows?
   require_relative 'file_wrapper'
@@ -33,6 +34,8 @@ end
 
 module Fluent::Plugin
   class TailInput < Fluent::Plugin::Input
+    include GroupWatch
+
     Fluent::Plugin.register_input('tail', self)
 
     helpers :timer, :event_loop, :parser, :compat_parameters
@@ -354,11 +357,11 @@ module Fluent::Plugin
 
     def existence_path
       hash = {}
-      @tails.each_key {|target_info|
+      @tails.each {|path, tw|
         if @follow_inodes
-          hash[target_info.ino] = target_info
+          hash[tw.ino] = TargetInfo.new(tw.path, tw.ino)
         else
-          hash[target_info.path] = target_info
+          hash[tw.path] = TargetInfo.new(tw.path, tw.ino)
         end
       }
       hash
@@ -406,6 +409,8 @@ module Fluent::Plugin
         event_loop_attach(watcher)
       end
 
+      tw.group_watcher = add_path_to_group_watcher(target_info.path)
+
       tw
     rescue => e
       if tw
@@ -420,36 +425,31 @@ module Fluent::Plugin
     end
 
     def construct_watcher(target_info)
+      path = target_info.path
+
+      # The file might be rotated or removed after collecting paths, so check inode again here.
+      begin
+        target_info.ino = Fluent::FileWrapper.stat(path).ino
+      rescue Errno::ENOENT, Errno::EACCES
+        $log.warn "stat() for #{path} failed. Continuing without tailing it."
+        return
+      end
+
       pe = nil
       if @pf
         pe = @pf[target_info]
-        if @read_from_head && pe.read_inode.zero?
-          begin
-            pe.update(Fluent::FileWrapper.stat(target_info.path).ino, 0)
-          rescue Errno::ENOENT, Errno::EACCES
-            $log.warn "stat() for #{target_info.path} failed. Continuing without tailing it."
-          end
-        end
+        pe.update(target_info.ino, 0) if @read_from_head && pe.read_inode.zero?
       end
 
       begin
         tw = setup_watcher(target_info, pe)
       rescue WatcherSetupError => e
-        log.warn "Skip #{target_info.path} because unexpected setup error happens: #{e}"
+        log.warn "Skip #{path} because unexpected setup error happens: #{e}"
         return
       end
 
-      begin
-        target_info = TargetInfo.new(target_info.path, Fluent::FileWrapper.stat(target_info.path).ino)
-        @tails.delete(target_info)
-        @tails[target_info] = tw
-        tw.on_notify
-      rescue Errno::ENOENT, Errno::EACCES => e
-        $log.warn "stat() for #{target_info.path} failed with #{e.class.name}. Drop tail watcher for now."
-        # explicitly detach and unwatch watcher `tw`.
-        tw.unwatched = true
-        detach_watcher(tw, target_info.ino, false)
-      end
+      @tails[path] = tw
+      tw.on_notify
     end
 
     def start_watchers(targets_info)
@@ -461,10 +461,12 @@ 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)
+          tw = @tails.delete(target_info.path)
         else
-          tw = @tails[target_info]
+          tw = @tails[target_info.path]
         end
         if tw
           tw.unwatched = unwatched
@@ -478,8 +480,8 @@ module Fluent::Plugin
     end
 
     def close_watcher_handles
-      @tails.keys.each do |target_info|
-        tw = @tails.delete(target_info)
+      @tails.keys.each do |path|
+        tw = @tails.delete(path)
         if tw
           tw.close
         end
@@ -488,20 +490,21 @@ module Fluent::Plugin
 
     # refresh_watchers calls @tails.keys so we don't use stop_watcher -> start_watcher sequence for safety.
     def update_watcher(target_info, pe)
-      log.info("detected rotation of #{target_info.path}; waiting #{@rotate_wait} seconds")
+      path = target_info.path
+
+      log.info("detected rotation of #{path}; waiting #{@rotate_wait} seconds")
 
       if @pf
         pe_inode = pe.read_inode
-        target_info_from_position_entry = TargetInfo.new(target_info.path, pe_inode)
+        target_info_from_position_entry = TargetInfo.new(path, pe_inode)
         unless pe_inode == @pf[target_info_from_position_entry].read_inode
-          log.debug "Skip update_watcher because watcher has been already updated by other inotify event"
+          log.warn "Skip update_watcher because watcher has been already updated by other inotify event",
+                   path: path, inode: pe.read_inode, inode_in_pos_file: @pf[target_info_from_position_entry].read_inode
           return
         end
       end
 
-      rotated_target_info = TargetInfo.new(target_info.path, pe.read_inode)
-      rotated_tw = @tails[rotated_target_info]
-      new_target_info = target_info.dup
+      rotated_tw = @tails[path]
 
       if @follow_inodes
         new_position_entry = @pf[target_info]
@@ -509,17 +512,13 @@ module Fluent::Plugin
         if new_position_entry.read_inode == 0
           # When follow_inodes is true, it's not cleaned up by refresh_watcher.
           # So it should be unwatched here explicitly.
-          rotated_tw.unwatched = true
-          # Make sure to delete old key, it has a different ino while the hash key is same.
-          @tails.delete(rotated_target_info)
-          @tails[new_target_info] = setup_watcher(new_target_info, new_position_entry)
-          @tails[new_target_info].on_notify
+          rotated_tw.unwatched = true if rotated_tw
+          @tails[path] = setup_watcher(target_info, new_position_entry)
+          @tails[path].on_notify
         end
       else
-        # Make sure to delete old key, it has a different ino while the hash key is same.
-        @tails.delete(rotated_target_info)
-        @tails[new_target_info] = setup_watcher(new_target_info, pe)
-        @tails[new_target_info].on_notify
+        @tails[path] = setup_watcher(target_info, pe)
+        @tails[path].on_notify
       end
       detach_watcher_after_rotate_wait(rotated_tw, pe.read_inode) if rotated_tw
     end
@@ -542,18 +541,19 @@ module Fluent::Plugin
       end
     end
 
+    def throttling_is_enabled?(tw)
+      return true if @read_bytes_limit_per_second > 0
+      return true if tw.group_watcher && tw.group_watcher.limit >= 0
+      false
+    end
+
     def detach_watcher_after_rotate_wait(tw, ino)
       # Call event_loop_attach/event_loop_detach is high-cost for short-live object.
       # If this has a problem with large number of files, use @_event_loop directly instead of timer_execute.
       if @open_on_every_update
         # Detach now because it's already closed, waiting it doesn't make sense.
         detach_watcher(tw, ino)
-      elsif @read_bytes_limit_per_second < 0
-        # throttling isn't enabled, just wait @rotate_wait
-        timer_execute(:in_tail_close_watcher, @rotate_wait, repeat: false) do
-          detach_watcher(tw, ino)
-        end
-      else
+      elsif throttling_is_enabled?(tw)
         # When the throttling feature is enabled, it might not reach EOF yet.
         # Should ensure to read all contents before closing it, with keeping throttling.
         start_time_to_wait = Fluent::Clock.now
@@ -564,6 +564,11 @@ module Fluent::Plugin
             detach_watcher(tw, ino)
           end
         end
+      else
+        # when the throttling feature isn't enabled, just wait @rotate_wait
+        timer_execute(:in_tail_close_watcher, @rotate_wait, repeat: false) do
+          detach_watcher(tw, ino)
+        end
       end
     end
 
@@ -775,6 +780,7 @@ module Fluent::Plugin
       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 tag
         @parsed_tag ||= @path.tr('/', '.').gsub(/\.+/, '.').gsub(/^\./, '')
@@ -997,6 +1003,10 @@ module Fluent::Plugin
           @log.info "following tail of #{@path}"
         end
 
+        def group_watcher
+          @watcher.group_watcher
+        end
+
         def on_notify
           @notify_mutex.synchronize { handle_notify }
         end
@@ -1054,6 +1064,7 @@ module Fluent::Plugin
 
         def handle_notify
           return if limit_bytes_per_second_reached?
+          return if group_watcher&.limit_lines_reached?(@path)
 
           with_io do |io|
             begin
@@ -1063,17 +1074,26 @@ module Fluent::Plugin
                 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
                     @fifo.read_lines(@lines)
+                    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 limit_bytes_per_second_reached? || should_shutdown_now?
+                    if group_watcher_limit || limit_bytes_per_second_reached? || should_shutdown_now?
                       # Just get out from tailing loop.
                       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

data/lib/fluent/plugin/out_file.rb

@@ -188,6 +188,10 @@ module Fluent::Plugin
         condition = Gem::Dependency.new('', [">= 2.7.0", "< 3.1.0"])
         @need_ruby_on_macos_workaround = true if condition.match?('', RUBY_VERSION)
       end
+
+      if @need_lock && @append && @fluentd_lock_dir.nil?
+        raise Fluent::InvalidLockDirectory, "must set FLUENTD_LOCK_DIR on multi-worker append mode"
+      end
     end
 
     def multi_workers_ready?
@@ -217,7 +221,13 @@ module Fluent::Plugin
                end
 
       if @append
-        writer.call(path, chunk)
+        if @need_lock
+          acquire_worker_lock(path) do
+            writer.call(path, chunk)
+          end
+        else
+          writer.call(path, chunk)
+        end
       else
         find_filepath_available(path, with_lock: @need_lock) do |actual_path|
           writer.call(actual_path, chunk)

data/lib/fluent/plugin/out_forward/socket_cache.rb

@@ -50,6 +50,7 @@ module Fluent::Plugin
       def checkin(sock)
         @mutex.synchronize do
           if (s = @inflight_sockets.delete(sock))
+            s.timeout = timeout
             @available_sockets[s.key] << s
           else
             @log.debug("there is no socket #{sock}")
@@ -122,6 +123,7 @@ module Fluent::Plugin
         t = Time.now
         if (s = @available_sockets[key].find { |sock| !expired_socket?(sock, time: t) })
           @inflight_sockets[s.sock] = @available_sockets[key].delete(s)
+          s.timeout = timeout
           s
         else
           nil

data/lib/fluent/plugin/output.rb

@@ -235,6 +235,7 @@ module Fluent
         @dequeued_chunks_mutex = nil
         @output_enqueue_thread = nil
         @output_flush_threads = nil
+        @output_flush_thread_current_position = 0
 
         @simple_chunking = nil
         @chunk_keys = @chunk_key_accessors = @chunk_key_time = @chunk_key_tag = nil
@@ -492,6 +493,7 @@ module Fluent
           @dequeued_chunks = []
           @dequeued_chunks_mutex = Mutex.new
 
+          @output_flush_thread_current_position = 0
           @buffer_config.flush_thread_count.times do |i|
             thread_title = "flush_thread_#{i}".to_sym
             thread_state = FlushThreadState.new(nil, nil, Mutex.new, ConditionVariable.new)
@@ -503,7 +505,6 @@ module Fluent
               @output_flush_threads << thread_state
             end
           end
-          @output_flush_thread_current_position = 0
 
           if !@under_plugin_development && (@flush_mode == :interval || @chunk_key_time)
             @output_enqueue_thread = thread_create(:enqueue_thread, &method(:enqueue_thread_run))

data/lib/fluent/plugin/parser_syslog.rb

@@ -484,7 +484,7 @@ module Fluent
 
         time = begin
                  @time_parser_rfc5424.parse(time_str)
-               rescue Fluent::TimeParser::TimeParseError => e
+               rescue Fluent::TimeParser::TimeParseError
                  @time_parser_rfc5424_without_subseconds.parse(time_str)
                end
         record['time'] = time_str if @keep_time_key

data/lib/fluent/plugin_helper/child_process.rb

@@ -346,6 +346,9 @@ module Fluent
           if cb
             cb.call(process_info.exit_status) rescue nil
           end
+          process_info.readio&.close rescue nil
+          process_info.writeio&.close rescue nil
+          process_info.stderrio&.close rescue nil
         end
         thread[:_fluentd_plugin_helper_child_process_running] = true
         thread[:_fluentd_plugin_helper_child_process_pid] = pid

data/lib/fluent/plugin_helper/server.rb

@@ -267,7 +267,9 @@ module Fluent
           ### Socket Params ###
 
           # SO_LINGER 0 to send RST rather than FIN to avoid lots of connections sitting in TIME_WAIT at src.
-          # Set positive value if needing to send FIN on closing.
+          # Set positive value if needing to send FIN on closing on non-Windows.
+          # (On Windows, Fluentd can send FIN with zero `linger_timeout` since Fluentd doesn't set 0 to SO_LINGER on Windows.
+          # See `socket_option.rb`.)
           # NOTE:
             # Socket-options can be specified from each plugin as needed, so most of them is not defined here for now.
             # This is because there is no positive reason to do so.

data/lib/fluent/plugin_helper/service_discovery.rb

@@ -44,7 +44,7 @@ module Fluent
 
         @discovery_manager.start
         unless @discovery_manager.static_config?
-          timer_execute(@_plugin_helper_service_discovery_title, @_plugin_helper_service_discovery_iterval) do
+          timer_execute(@_plugin_helper_service_discovery_title, @_plugin_helper_service_discovery_interval) do
             @discovery_manager.run_once
           end
         end
@@ -96,7 +96,7 @@ module Fluent
       # @param custom_build_method [Proc]
       def service_discovery_create_manager(title, configurations:, load_balancer: nil, custom_build_method: nil, interval: 3)
         @_plugin_helper_service_discovery_title = title
-        @_plugin_helper_service_discovery_iterval = interval
+        @_plugin_helper_service_discovery_interval = interval
 
         @discovery_manager = Fluent::PluginHelper::ServiceDiscovery::Manager.new(
           log: log,

data/lib/fluent/supervisor.rb

@@ -16,6 +16,7 @@
 
 require 'fileutils'
 require 'open3'
+require 'pathname'
 
 require 'fluent/config'
 require 'fluent/counter'
@@ -31,12 +32,6 @@ require 'fluent/variable_store'
 require 'serverengine'
 
 if Fluent.windows?
-  require 'windows/library'
-  require 'windows/synchronize'
-  require 'windows/system_info'
-  include Windows::Library
-  include Windows::Synchronize
-  include Windows::SystemInfo
   require 'win32/ipc'
   require 'win32/event'
 end
@@ -49,6 +44,9 @@ module Fluent
       @rpc_server = nil
       @counter = nil
 
+      @fluentd_lock_dir = Dir.mktmpdir("fluentd-lock-")
+      ENV['FLUENTD_LOCK_DIR'] = @fluentd_lock_dir
+
       if config[:rpc_endpoint]
         @rpc_endpoint = config[:rpc_endpoint]
         @enable_get_dump = config[:enable_get_dump]
@@ -78,9 +76,15 @@ module Fluent
       stop_windows_event_thread if Fluent.windows?
       stop_rpc_server if @rpc_endpoint
       stop_counter_server if @counter
+      cleanup_lock_dir
       Fluent::Supervisor.cleanup_resources
     end
 
+    def cleanup_lock_dir
+      FileUtils.rm(Dir.glob(File.join(@fluentd_lock_dir, "fluentd-*.lock")))
+      FileUtils.rmdir(@fluentd_lock_dir)
+    end
+
     def run_rpc_server
       @rpc_server = RPC::Server.new(@rpc_endpoint, $log)
 
@@ -215,44 +219,51 @@ module Fluent
       Thread.new do
         ipc = Win32::Ipc.new(nil)
         events = [
-          Win32::Event.new("#{@pid_signame}_STOP_EVENT_THREAD"),
-          Win32::Event.new("#{@pid_signame}"),
-          Win32::Event.new("#{@pid_signame}_HUP"),
-          Win32::Event.new("#{@pid_signame}_USR1"),
-          Win32::Event.new("#{@pid_signame}_USR2"),
+          {win32_event: Win32::Event.new("#{@pid_signame}_STOP_EVENT_THREAD"), action: :stop_event_thread},
+          {win32_event: Win32::Event.new("#{@pid_signame}"), action: :stop},
+          {win32_event: Win32::Event.new("#{@pid_signame}_HUP"), action: :hup},
+          {win32_event: Win32::Event.new("#{@pid_signame}_USR1"), action: :usr1},
+          {win32_event: Win32::Event.new("#{@pid_signame}_USR2"), action: :usr2},
+          {win32_event: Win32::Event.new("#{@pid_signame}_CONT"), action: :cont},
         ]
         if @signame
           signame_events = [
-            Win32::Event.new("#{@signame}"),
-            Win32::Event.new("#{@signame}_HUP"),
-            Win32::Event.new("#{@signame}_USR1"),
-            Win32::Event.new("#{@signame}_USR2"),
+            {win32_event: Win32::Event.new("#{@signame}"), action: :stop},
+            {win32_event: Win32::Event.new("#{@signame}_HUP"), action: :hup},
+            {win32_event: Win32::Event.new("#{@signame}_USR1"), action: :usr1},
+            {win32_event: Win32::Event.new("#{@signame}_USR2"), action: :usr2},
+            {win32_event: Win32::Event.new("#{@signame}_CONT"), action: :cont},
           ]
           events.concat(signame_events)
         end
         begin
           loop do
-            idx = ipc.wait_any(events, Windows::Synchronize::INFINITE)
-            if idx > 0 && idx <= events.length
-              $log.debug("Got Win32 event \"#{events[idx - 1].name}\"")
+            infinite = 0xFFFFFFFF
+            ipc_idx = ipc.wait_any(events.map {|e| e[:win32_event]}, infinite)
+            event_idx = ipc_idx - 1
+
+            if event_idx >= 0 && event_idx < events.length
+              $log.debug("Got Win32 event \"#{events[event_idx][:win32_event].name}\"")
             else
-              $log.warn("Unexpected reutrn value of Win32::Ipc#wait_any: #{idx}")
+              $log.warn("Unexpected return value of Win32::Ipc#wait_any: #{ipc_idx}")
             end
-            case idx
-            when 2, 6
+            case events[event_idx][:action]
+            when :stop
               stop(true)
-            when 3, 7
+            when :hup
               supervisor_sighup_handler
-            when 4, 8
+            when :usr1
               supervisor_sigusr1_handler
-            when 5, 9
+            when :usr2
               supervisor_sigusr2_handler
-            when 1
+            when :cont
+              supervisor_dump_handler_for_windows
+            when :stop_event_thread
               break
             end
           end
         ensure
-          events.each { |event| event.close }
+          events.each { |event| event[:win32_event].close }
         end
       end
     end
@@ -302,6 +313,26 @@ module Fluent
       $log.error "Failed to reload config file: #{e}"
     end
 
+    def supervisor_dump_handler_for_windows
+      # As for UNIX-like, SIGCONT signal to each process makes the process output its dump-file,
+      # and it is implemented before the implementation of the function for Windows.
+      # It is possible to trap SIGCONT and handle it here also on UNIX-like,
+      # but for backward compatibility, this handler is currently for a Windows-only.
+      raise "[BUG] This function is for Windows ONLY." unless Fluent.windows?
+
+      Thread.new do
+        begin
+          FluentSigdump.dump_windows
+        rescue => e
+          $log.error "failed to dump: #{e}"
+        end
+      end
+
+      send_signal_to_workers(:CONT)
+    rescue => e
+      $log.error "failed to dump: #{e}"
+    end
+
     def kill_worker
       if config[:worker_pid]
         pids = config[:worker_pid].clone
@@ -358,6 +389,14 @@ module Fluent
         restart(true)
       when :USR2
         reload
+      when :CONT
+        dump_all_windows_workers
+      end
+    end
+
+    def dump_all_windows_workers
+      @monitors.each do |m|
+        m.send_command("DUMP\n")
       end
     end
   end
@@ -458,7 +497,8 @@ module Fluent
         config_path: path,
         main_cmd: params['main_cmd'],
         signame: params['signame'],
-        disable_shared_socket: params['disable_shared_socket']
+        disable_shared_socket: params['disable_shared_socket'],
+        restart_worker_interval: params['restart_worker_interval'],
       }
       if daemonize
         se_config[:pid_path] = pid_path
@@ -580,7 +620,8 @@ module Fluent
         standalone_worker: false,
         signame: nil,
         conf_encoding: 'utf-8',
-        disable_shared_socket: nil
+        disable_shared_socket: nil,
+        config_file_type: :guess,
       }
     end
 
@@ -593,6 +634,7 @@ module Fluent
     end
 
     def initialize(opt)
+      @config_file_type = opt[:config_file_type]
       @daemonize = opt[:daemonize]
       @standalone_worker= opt[:standalone_worker]
       @config_path = opt[:config_path]
@@ -618,7 +660,9 @@ module Fluent
         @conf = Fluent::Config.build(config_path: @config_path,
                                      encoding: @conf_encoding ? @conf_encoding : 'utf-8',
                                      additional_config: @inline_config ? @inline_config : nil,
-                                     use_v1_config: !!@use_v1_config)
+                                     use_v1_config: !!@use_v1_config,
+                                     type: @config_file_type,
+                                    )
         @system_config = build_system_config(@conf)
         if @system_config.log
           @log_rotate_age ||= @system_config.log.rotate_age
@@ -744,7 +788,13 @@ module Fluent
         $log.warn('the value "-" for `inline_config` is deprecated. See https://github.com/fluent/fluentd/issues/2711')
         @inline_config = STDIN.read
       end
-      @conf = Fluent::Config.build(config_path: @config_path, encoding: @conf_encoding, additional_config: @inline_config, use_v1_config: @use_v1_config)
+      @conf = Fluent::Config.build(
+        config_path: @config_path,
+        encoding: @conf_encoding,
+        additional_config: @inline_config,
+        use_v1_config: @use_v1_config,
+        type: @config_file_type,
+      )
       @system_config = build_system_config(@conf)
 
       @log.level = @system_config.log_level
@@ -822,12 +872,14 @@ module Fluent
         'counter_server' => @system_config.counter_server,
         'log_format' => @system_config.log.format,
         'log_time_format' => @system_config.log.time_format,
-        'disable_shared_socket' => @system_config.disable_shared_socket
+        'disable_shared_socket' => @system_config.disable_shared_socket,
+        'restart_worker_interval' => @system_config.restart_worker_interval,
       }
 
       se = ServerEngine.create(ServerModule, WorkerModule){
         Fluent::Supervisor.load_config(@config_path, params)
       }
+
       se.run
     end
 
@@ -896,6 +948,9 @@ module Fluent
           when "RELOAD"
             $log.debug "fluentd main process get #{cmd} command"
             reload_config
+          when "DUMP"
+            $log.debug "fluentd main process get #{cmd} command"
+            dump
           else
             $log.warn "fluentd main process get unknown command [#{cmd}]"
           end
@@ -929,6 +984,7 @@ module Fluent
             encoding: @conf_encoding,
             additional_config: @inline_config,
             use_v1_config: @use_v1_config,
+            type: @config_file_type,
           )
 
           Fluent::VariableStore.try_to_reset do
@@ -945,6 +1001,16 @@ module Fluent
       end
     end
 
+    def dump
+      Thread.new do
+        begin
+          FluentSigdump.dump_windows
+        rescue => e
+          $log.error("failed to dump: #{e}")
+        end
+      end
+    end
+
     def logging_with_console_output
       yield $log
       unless @log.stdout?
@@ -1039,6 +1105,11 @@ module Fluent
         fluentd_spawn_cmd << '-Eascii-8bit:ascii-8bit'
       end
 
+      if @system_config.enable_jit
+        $log.info "enable Ruby JIT for workers (--jit)"
+        fluentd_spawn_cmd << '--jit'
+      end
+
       # Adding `-h` so that it can avoid ruby's command blocking
       # e.g. `ruby -Eascii-8bit:ascii-8bit` will block. but `ruby -Eascii-8bit:ascii-8bit -h` won't.
       _, e, s = Open3.capture3(*fluentd_spawn_cmd, "-h")
@@ -1054,4 +1125,27 @@ module Fluent
       fluentd_spawn_cmd
     end
   end
+
+  module FluentSigdump
+    def self.dump_windows
+      raise "[BUG] WindowsSigdump::dump is for Windows ONLY." unless Fluent.windows?
+
+      # Sigdump outputs under `/tmp` dir without `SIGDUMP_PATH` specified,
+      # but `/tmp` dir may not exist on Windows by default.
+      # So use the systemroot-temp-dir instead.
+      dump_filepath = ENV['SIGDUMP_PATH'].nil? || ENV['SIGDUMP_PATH'].empty? \
+        ? "#{ENV['windir']}/Temp/fluentd-sigdump-#{Process.pid}.log"
+        : get_path_with_pid(ENV['SIGDUMP_PATH'])
+
+      require 'sigdump'
+      Sigdump.dump(dump_filepath)
+
+      $log.info "dump to #{dump_filepath}."
+    end
+
+    def self.get_path_with_pid(raw_path)
+      path = Pathname.new(raw_path)
+      path.sub_ext("-#{Process.pid}#{path.extname}").to_s
+    end
+  end
 end