fluentd 0.12.40 → 1.6.2

data/lib/fluent/supervisor.rb

@@ -14,78 +14,389 @@
 #    limitations under the License.
 #
 
-require 'etc'
-require 'fcntl'
-
-begin
-  require 'sigdump/setup'
-rescue Exception
-  # ignore LoadError and others (related with signals): it may raise these errors in Windows
-end
+require 'fileutils'
 
 require 'fluent/config'
+require 'fluent/counter'
 require 'fluent/env'
 require 'fluent/engine'
+require 'fluent/error'
 require 'fluent/log'
 require 'fluent/plugin'
 require 'fluent/rpc'
 require 'fluent/system_config'
+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
 
 module Fluent
-  class Supervisor
-    def self.get_etc_passwd(user)
-      if user.to_i.to_s == user
-        Etc.getpwuid(user.to_i)
-      else
-        Etc.getpwnam(user)
+  module ServerModule
+    def before_run
+      @start_time = Time.now
+      @rpc_server = nil
+      @counter = nil
+
+      if config[:rpc_endpoint]
+        @rpc_endpoint = config[:rpc_endpoint]
+        @enable_get_dump = config[:enable_get_dump]
+        run_rpc_server
       end
+      install_supervisor_signal_handlers
+
+      if config[:signame]
+        @signame = config[:signame]
+        install_windows_event_handler
+      end
+
+      if counter = config[:counter_server]
+        run_counter_server(counter)
+      end
+
+      socket_manager_path = ServerEngine::SocketManager::Server.generate_path
+      ServerEngine::SocketManager::Server.open(socket_manager_path)
+      ENV['SERVERENGINE_SOCKETMANAGER_PATH'] = socket_manager_path.to_s
     end
 
-    def self.get_etc_group(group)
-      if group.to_i.to_s == group
-        Etc.getgrgid(group.to_i)
-      else
-        Etc.getgrnam(group)
+    def after_run
+      stop_rpc_server if @rpc_endpoint
+      stop_counter_server if @counter
+      Fluent::Supervisor.cleanup_resources
+    end
+
+    def run_rpc_server
+      @rpc_server = RPC::Server.new(@rpc_endpoint, $log)
+
+      # built-in RPC for signals
+      @rpc_server.mount_proc('/api/processes.interruptWorkers') { |req, res|
+        $log.debug "fluentd RPC got /api/processes.interruptWorkers request"
+        Process.kill :INT, $$
+        nil
+      }
+      @rpc_server.mount_proc('/api/processes.killWorkers') { |req, res|
+        $log.debug "fluentd RPC got /api/processes.killWorkers request"
+        Process.kill :TERM, $$
+        nil
+      }
+      @rpc_server.mount_proc('/api/processes.flushBuffersAndKillWorkers') { |req, res|
+        $log.debug "fluentd RPC got /api/processes.flushBuffersAndKillWorkers request"
+        if Fluent.windows?
+          $log.warn "operation 'flushBuffersAndKillWorkers' is not supported on Windows now."
+        else
+          Process.kill :USR1, $$
+          Process.kill :TERM, $$
+        end
+        nil
+      }
+      @rpc_server.mount_proc('/api/plugins.flushBuffers') { |req, res|
+        $log.debug "fluentd RPC got /api/plugins.flushBuffers request"
+        unless Fluent.windows?
+          Process.kill :USR1, $$
+        end
+        nil
+      }
+      @rpc_server.mount_proc('/api/config.reload') { |req, res|
+        $log.debug "fluentd RPC got /api/config.reload request"
+        if Fluent.windows?
+          # restart worker with auto restarting by killing
+          kill_worker
+        else
+          Process.kill :HUP, $$
+        end
+        nil
+      }
+      @rpc_server.mount_proc('/api/config.dump') { |req, res|
+        $log.debug "fluentd RPC got /api/config.dump request"
+        $log.info "dump in-memory config"
+        supervisor_dump_config_handler
+        nil
+      }
+
+      @rpc_server.mount_proc('/api/config.getDump') { |req, res|
+        $log.debug "fluentd RPC got /api/config.dump request"
+        $log.info "get dump in-memory config via HTTP"
+        res.body = supervisor_get_dump_config_handler
+        [nil, nil, res]
+      } if @enable_get_dump
+
+      @rpc_server.start
+    end
+
+    def stop_rpc_server
+      @rpc_server.shutdown
+    end
+
+    def run_counter_server(counter_conf)
+      @counter = Fluent::Counter::Server.new(
+        counter_conf.scope,
+        {host: counter_conf.bind, port: counter_conf.port, log: $log, path: counter_conf.backup_path}
+      )
+      @counter.start
+    end
+
+    def stop_counter_server
+      @counter.stop
+    end
+
+    def install_supervisor_signal_handlers
+      trap :HUP do
+        $log.debug "fluentd supervisor process get SIGHUP"
+        supervisor_sighup_handler
+      end unless Fluent.windows?
+
+      trap :USR1 do
+        $log.debug "fluentd supervisor process get SIGUSR1"
+        supervisor_sigusr1_handler
+      end unless Fluent.windows?
+    end
+
+    def install_windows_event_handler
+      Thread.new do
+        ev = Win32::Event.new(@signame)
+        begin
+          ev.reset
+          until WaitForSingleObject(ev.handle, 0) == WAIT_OBJECT_0
+            sleep 1
+          end
+          kill_worker
+          stop(true)
+        ensure
+          ev.close
+        end
       end
     end
 
+    def supervisor_sighup_handler
+      kill_worker
+    end
+
+    def supervisor_sigusr1_handler
+      if log = config[:logger_initializer]
+        # Creating new thread due to mutex can't lock
+        # in main thread during trap context
+        Thread.new {
+          log.reopen!
+        }.run
+      end
+
+      if config[:worker_pid]
+        config[:worker_pid].each_value do |pid|
+          Process.kill(:USR1, pid)
+          # don't rescue Errno::ESRCH here (invalid status)
+        end
+      end
+    end
+
+    def kill_worker
+      if config[:worker_pid]
+        pids = config[:worker_pid].clone
+        config[:worker_pid].clear
+        pids.each_value do |pid|
+          if Fluent.windows?
+            Process.kill :KILL, pid
+          else
+            Process.kill :TERM, pid
+          end
+        end
+      end
+    end
+
+    def supervisor_dump_config_handler
+      $log.info config[:fluentd_conf].to_s
+    end
+
+    def supervisor_get_dump_config_handler
+      {conf: config[:fluentd_conf].to_s}
+    end
+  end
+
+  module WorkerModule
+    def spawn(process_manager)
+      main_cmd = config[:main_cmd]
+      env = {
+        'SERVERENGINE_WORKER_ID' => @worker_id.to_i.to_s,
+      }
+      @pm = process_manager.spawn(env, *main_cmd)
+    end
+
+    def after_start
+      (config[:worker_pid] ||= {})[@worker_id] = @pm.pid
+    end
+  end
+
+  class Supervisor
+    def self.load_config(path, params = {})
+
+      pre_loadtime = 0
+      pre_loadtime = params['pre_loadtime'].to_i if params['pre_loadtime']
+      pre_config_mtime = nil
+      pre_config_mtime = params['pre_config_mtime'] if params['pre_config_mtime']
+      config_mtime = File.mtime(path)
+
+      # reuse previous config if last load time is within 5 seconds and mtime of the config file is not changed
+      if Time.now - Time.at(pre_loadtime) < 5 and config_mtime == pre_config_mtime
+        return params['pre_conf']
+      end
+
+      config_fname = File.basename(path)
+      config_basedir = File.dirname(path)
+      # Assume fluent.conf encoding is UTF-8
+      config_data = File.open(path, "r:#{params['conf_encoding']}:utf-8") {|f| f.read }
+      inline_config = params['inline_config']
+      if inline_config == '-'
+        config_data << "\n" << STDIN.read
+      elsif inline_config
+        config_data << "\n" << inline_config.gsub("\\n","\n")
+      end
+      fluentd_conf = Fluent::Config.parse(config_data, config_fname, config_basedir, params['use_v1_config'])
+      system_config = SystemConfig.create(fluentd_conf)
+
+      # these params must NOT be configured via system config here.
+      # these may be overridden by command line params.
+      workers = params['workers']
+      root_dir = params['root_dir']
+      log_level = params['log_level']
+      suppress_repeated_stacktrace = params['suppress_repeated_stacktrace']
+
+      log_path = params['log_path']
+      chuser = params['chuser']
+      chgroup = params['chgroup']
+      log_rotate_age = params['log_rotate_age']
+      log_rotate_size = params['log_rotate_size']
+      rpc_endpoint = system_config.rpc_endpoint
+      enable_get_dump = system_config.enable_get_dump
+      counter_server = system_config.counter_server
+
+      log_opts = {suppress_repeated_stacktrace: suppress_repeated_stacktrace}
+      logger_initializer = Supervisor::LoggerInitializer.new(
+        log_path, log_level, chuser, chgroup, log_opts,
+        log_rotate_age: log_rotate_age,
+        log_rotate_size: log_rotate_size
+      )
+      # this #init sets initialized logger to $log
+      logger_initializer.init(:supervisor, 0)
+      logger = $log
+
+      command_sender = Fluent.windows? ? "pipe" : "signal"
+
+      # ServerEngine's "daemonize" option is boolean, and path of pid file is brought by "pid_path"
+      pid_path = params['daemonize']
+      daemonize = !!params['daemonize']
+      main_cmd = params['main_cmd']
+      signame = params['signame']
+
+      se_config = {
+          worker_type: 'spawn',
+          workers: workers,
+          log_stdin: false,
+          log_stdout: false,
+          log_stderr: false,
+          enable_heartbeat: true,
+          auto_heartbeat: false,
+          unrecoverable_exit_codes: [2],
+          stop_immediately_at_unrecoverable_exit: true,
+          root_dir: root_dir,
+          logger: logger,
+          log: logger.out,
+          log_path: log_path,
+          log_level: log_level,
+          logger_initializer: logger_initializer,
+          chuser: chuser,
+          chgroup: chgroup,
+          chumask: 0,
+          suppress_repeated_stacktrace: suppress_repeated_stacktrace,
+          daemonize: daemonize,
+          rpc_endpoint: rpc_endpoint,
+          counter_server: counter_server,
+          enable_get_dump: enable_get_dump,
+          windows_daemon_cmdline: [ServerEngine.ruby_bin_path,
+                                   File.join(File.dirname(__FILE__), 'daemon.rb'),
+                                   ServerModule.name,
+                                   WorkerModule.name,
+                                   path,
+                                   JSON.dump(params)],
+          command_sender: command_sender,
+          fluentd_conf: fluentd_conf,
+          main_cmd: main_cmd,
+          signame: signame,
+      }
+      if daemonize
+        se_config[:pid_path] = pid_path
+      end
+      pre_params = params.dup
+      params['pre_loadtime'] = Time.now.to_i
+      params['pre_config_mtime'] = config_mtime
+      params['pre_conf'] = se_config
+      # prevent pre_conf from being too big by reloading many times.
+      pre_params['pre_conf'] = nil
+      params['pre_conf'][:windows_daemon_cmdline][5] = JSON.dump(pre_params)
+
+      return se_config
+    end
+
     class LoggerInitializer
-      def initialize(path, level, chuser, chgroup, opts)
+      def initialize(path, level, chuser, chgroup, opts, log_rotate_age: nil, log_rotate_size: nil)
         @path = path
         @level = level
         @chuser = chuser
         @chgroup = chgroup
         @opts = opts
+        @log_rotate_age = log_rotate_age
+        @log_rotate_size = log_rotate_size
       end
 
-      def init
+      def init(process_type, worker_id)
+        @opts[:process_type] = process_type
+        @opts[:worker_id] = worker_id
+
         if @path && @path != "-"
-          @io = File.open(@path, "a")
+          @logdev = if @log_rotate_age || @log_rotate_size
+                     Fluent::LogDeviceIO.new(@path, shift_age: @log_rotate_age, shift_size: @log_rotate_size)
+                   else
+                     File.open(@path, "a")
+                   end
           if @chuser || @chgroup
-            chuid = @chuser ? Supervisor.get_etc_passwd(@chuser).uid : nil
-            chgid = @chgroup ? Supervisor.get_etc_group(@chgroup).gid : nil
+            chuid = @chuser ? ServerEngine::Privilege.get_etc_passwd(@chuser).uid : nil
+            chgid = @chgroup ? ServerEngine::Privilege.get_etc_group(@chgroup).gid : nil
             File.chown(chuid, chgid, @path)
           end
         else
-          @io = STDOUT
+          @logdev = STDOUT
         end
 
-        $log = Fluent::Log.new(@io, @level, @opts)
+        dl_opts = {}
+        # subtract 1 to match serverengine daemon logger side logging severity.
+        dl_opts[:log_level] = @level - 1
+        logger = ServerEngine::DaemonLogger.new(@logdev, dl_opts)
+        $log = Fluent::Log.new(logger, @opts)
         $log.enable_color(false) if @path
         $log.enable_debug if @level <= Fluent::Log::LEVEL_DEBUG
       end
 
       def stdout?
-        @io == STDOUT
+        @logdev == STDOUT
       end
 
       def reopen!
         if @path && @path != "-"
-          @io.reopen(@path, "a")
+          @logdev.reopen(@path, "a")
         end
         self
       end
 
+      def apply_options(opts)
+        $log.format = opts[:format] if opts[:format]
+        $log.time_format = opts[:time_format] if opts[:time_format]
+      end
+
       def level=(level)
         @level = level
         $log.level = level
@@ -103,20 +414,34 @@ module Fluent
         setup_path: nil,
         chuser: nil,
         chgroup: nil,
+        root_dir: nil,
         suppress_interval: 0,
         suppress_repeated_stacktrace: true,
-        without_source: false,
+        without_source: nil,
         use_v1_config: true,
         supervise: true,
+        standalone_worker: false,
+        signame: nil,
+        conf_encoding: 'utf-8'
       }
     end
 
+    def self.cleanup_resources
+      unless Fluent.windows?
+        if ENV.has_key?('SERVERENGINE_SOCKETMANAGER_PATH')
+          FileUtils.rm_f(ENV['SERVERENGINE_SOCKETMANAGER_PATH'])
+        end
+      end
+    end
+
     def initialize(opt)
       @daemonize = opt[:daemonize]
       @supervise = opt[:supervise]
+      @standalone_worker= opt[:standalone_worker]
       @config_path = opt[:config_path]
       @inline_config = opt[:inline_config]
       @use_v1_config = opt[:use_v1_config]
+      @conf_encoding = opt[:conf_encoding]
       @log_path = opt[:log_path]
       @dry_run = opt[:dry_run]
       @show_plugin_config = opt[:show_plugin_config]
@@ -127,57 +452,56 @@ module Fluent
       @rpc_server = nil
       @process_name = nil
 
+      @workers = opt[:workers]
+      @root_dir = opt[:root_dir]
       @log_level = opt[:log_level]
+      @log_rotate_age = opt[:log_rotate_age]
+      @log_rotate_size = opt[:log_rotate_size]
       @suppress_interval = opt[:suppress_interval]
       @suppress_config_dump = opt[:suppress_config_dump]
+      @log_event_verbose = opt[:log_event_verbose]
       @without_source = opt[:without_source]
-
-      log_opts = {suppress_repeated_stacktrace: opt[:suppress_repeated_stacktrace]}
-      @log = LoggerInitializer.new(@log_path, @log_level, @chuser, @chgroup, log_opts)
+      @signame = opt[:signame]
+
+      @suppress_repeated_stacktrace = opt[:suppress_repeated_stacktrace]
+      log_opts = {suppress_repeated_stacktrace: @suppress_repeated_stacktrace}
+      @log = LoggerInitializer.new(
+        @log_path, @log_level, @chuser, @chgroup, log_opts,
+        log_rotate_age: @log_rotate_age,
+        log_rotate_size: @log_rotate_size
+      )
       @finished = false
-      @main_pid = nil
     end
 
-    def start
-      @log.init
+    def run_supervisor
+      @log.init(:supervisor, 0)
       show_plugin_config if @show_plugin_config
       read_config
       set_system_config
+      @log.apply_options(format: @system_config.log.format, time_format: @system_config.log.time_format)
+
+      $log.info :supervisor, "parsing config file is succeeded", path: @config_path
 
-      dry_run if @dry_run
-      start_daemonize if @daemonize
-      setup_rpc_server if @rpc_endpoint
-      setup_rpc_get_dump if @enable_get_dump
-
-      if @supervise
-        install_supervisor_signal_handlers
-        run_rpc_server if @rpc_endpoint
-        until @finished
-          supervise do
-            change_privilege
-            init_engine
-            install_main_process_signal_handlers
-            run_configure
-            finish_daemonize if @daemonize
-            run_engine
-            exit 0
+      if @workers < 1
+        raise Fluent::ConfigError, "invalid number of workers (must be > 0):#{@workers}"
+      end
+
+      if @root_dir
+        if File.exist?(@root_dir)
+          unless Dir.exist?(@root_dir)
+            raise Fluent::InvalidRootDirectory, "non directory entry exists:#{@root_dir}"
+          end
+        else
+          begin
+            FileUtils.mkdir_p(@root_dir)
+          rescue => e
+            raise Fluent::InvalidRootDirectory, "failed to create root directory:#{@root_dir}, #{e.inspect}"
           end
-          $log.error "fluentd main process died unexpectedly. restarting." unless @finished
-        end
-      else
-        $log.info "starting fluentd-#{Fluent::VERSION} without supervision"
-        run_rpc_server if @rpc_endpoint
-        main_process do
-          change_privilege
-          init_engine
-          install_main_process_signal_handlers
-          run_configure
-          finish_daemonize if @daemonize
-          run_engine
-          exit 0
         end
       end
-      stop_rpc_server if @rpc_endpoint
+
+      dry_run_cmd if @dry_run
+      supervise
     end
 
     def options
@@ -185,293 +509,264 @@ module Fluent
         'config_path' => @config_path,
         'pid_file' => @daemonize,
         'plugin_dirs' => @plugin_dirs,
-        'log_path' => @log_path
+        'log_path' => @log_path,
+        'root_dir' => @root_dir,
       }
     end
 
-    private
-
-    def dry_run
-      $log.info "starting fluentd-#{Fluent::VERSION} as dry run mode"
-
-      change_privilege
-      init_engine
-      install_main_process_signal_handlers
-      run_configure
-      exit 0
-    rescue => e
-      $log.error "dry run failed: #{e}"
-      exit 1
-    end
-
-    def show_plugin_config
-      $log.info "Show config for #{@show_plugin_config}"
-      name, type = @show_plugin_config.split(":")
-      plugin = Plugin.__send__("new_#{name}", type)
-      dumped_config = "\n"
-      level = 0
-      plugin.class.ancestors.reverse_each do |plugin_class|
-        if plugin_class.respond_to?(:dump)
-          $log.on_debug do
-            dumped_config << plugin_class.name
-            dumped_config << "\n"
-            level = 1
-          end
-          dumped_config << plugin_class.dump(level)
-        end
-      end
-      $log.info dumped_config
-      exit 0
-    rescue => e
-      $log.error "show config failed: #{e}"
-      exit 1
-    end
-
-    def start_daemonize
-      @wait_daemonize_pipe_r, @wait_daemonize_pipe_w = IO.pipe
-
-      if fork
-        # console process
-        @wait_daemonize_pipe_w.close
-        @wait_daemonize_pipe_w = nil
-        wait_daemonize
-        exit 0
+    def run_worker
+      begin
+        require 'sigdump/setup'
+      rescue Exception
+        # ignore LoadError and others (related with signals): it may raise these errors in Windows
       end
+      worker_id = ENV['SERVERENGINE_WORKER_ID'].to_i
+      process_type = case
+                     when @standalone_worker then :standalone
+                     when worker_id == 0 then :worker0
+                     else :workers
+                     end
+      @log.init(process_type, worker_id)
+      show_plugin_config if @show_plugin_config
+      read_config
+      set_system_config
+      @log.apply_options(format: @system_config.log.format, time_format: @system_config.log.time_format)
 
-      # daemonize intermediate process
-      @wait_daemonize_pipe_r.close
-      @wait_daemonize_pipe_r = nil
-
-      # in case the child process forked during run_configure
-      @wait_daemonize_pipe_w.fcntl(Fcntl::F_SETFD, Fcntl::FD_CLOEXEC)
-
-      Process.setsid
-      exit!(0) if fork
-      File.umask(0)
-
-      # supervisor process
-      @supervisor_pid = Process.pid
-    end
+      Process.setproctitle("worker:#{@process_name}") if @process_name
 
-    def wait_daemonize
-      supervisor_pid = @wait_daemonize_pipe_r.read
-      if supervisor_pid.empty?
-        # initialization failed
-        exit! 1
+      if @standalone_worker && @workers != 1
+        raise Fluent::ConfigError, "invalid number of workers (must be 1 or unspecified) with --no-supervisor: #{@workers}"
       end
 
-      @wait_daemonize_pipe_r.close
-      @wait_daemonize_pipe_r = nil
+      install_main_process_signal_handlers
 
-      # write pid file
-      File.open(@daemonize, "w") {|f|
-        f.write supervisor_pid
-      }
-    end
+      # This is the only log messsage for @standalone_worker
+      $log.info "starting fluentd-#{Fluent::VERSION} without supervision", pid: Process.pid, ruby: RUBY_VERSION if @standalone_worker
 
-    def finish_daemonize
-      if @wait_daemonize_pipe_w
-        STDIN.reopen("/dev/null")
-        STDOUT.reopen("/dev/null", "w")
-        STDERR.reopen("/dev/null", "w")
-        @wait_daemonize_pipe_w.write @supervisor_pid.to_s
-        @wait_daemonize_pipe_w.close
-        @wait_daemonize_pipe_w = nil
+      main_process do
+        create_socket_manager if @standalone_worker
+        change_privilege if @standalone_worker
+        init_engine
+        run_configure
+        run_engine
+        self.class.cleanup_resources if @standalone_worker
+        exit 0
       end
     end
 
-    def setup_rpc_server
-      @rpc_server = RPC::Server.new(@rpc_endpoint, $log)
+    private
 
-      # built-in RPC for signals
-      @rpc_server.mount_proc('/api/processes.interruptWorkers') { |req, res|
-        $log.debug "fluentd RPC got /api/processes.interruptWorkers request"
-        supervisor_sigint_handler
-        nil
-      }
-      @rpc_server.mount_proc('/api/processes.killWorkers') { |req, res|
-        $log.debug "fluentd RPC got /api/processes.killWorkers request"
-        supervisor_sigterm_handler
-        nil
-      }
-      @rpc_server.mount_proc('/api/plugins.flushBuffers') { |req, res|
-        $log.debug "fluentd RPC got /api/plugins.flushBuffers request"
-        supervisor_sigusr1_handler
-        nil
-      }
-      @rpc_server.mount_proc('/api/config.reload') { |req, res|
-        $log.debug "fluentd RPC got /api/config.reload request"
-        $log.info "restarting"
-        supervisor_sighup_handler
-        nil
-      }
-      @rpc_server.mount_proc('/api/config.dump') { |req, res|
-        $log.debug "fluentd RPC got /api/config.dump request"
-        $log.info "dump in-memory config"
-        supervisor_dump_config_handler
-        nil
-      }
+    def create_socket_manager
+      socket_manager_path = ServerEngine::SocketManager::Server.generate_path
+      ServerEngine::SocketManager::Server.open(socket_manager_path)
+      ENV['SERVERENGINE_SOCKETMANAGER_PATH'] = socket_manager_path.to_s
     end
 
-    def setup_rpc_get_dump
-      @rpc_server.mount_proc('/api/config.getDump') { |req, res|
-        $log.debug "fluentd RPC got /api/config.dump request"
-        $log.info "get dump in-memory config via HTTP"
-        res.body = supervisor_get_dump_config_handler
-        [nil, nil, res]
-      }
+    def dry_run_cmd
+      $log.info "starting fluentd-#{Fluent::VERSION} as dry run mode", ruby: RUBY_VERSION
+      @system_config.suppress_config_dump = true
+      dry_run
+      exit 0
+    rescue => e
+      $log.error "dry run failed: #{e}"
+      exit 1
     end
 
-    def run_rpc_server
-      @rpc_server.start
+    ## Set Engine's dry_run_mode true to override all target_id of worker sections
+    def dry_run
+      begin
+        Fluent::Engine.dry_run_mode = true
+        change_privilege
+        init_engine
+        run_configure
+      rescue Fluent::ConfigError => e
+        $log.error "config error", file: @config_path, error: e
+        $log.debug_backtrace
+        exit!(1)
+      ensure
+        Fluent::Engine.dry_run_mode = false
+      end
     end
 
-    def stop_rpc_server
-      @rpc_server.shutdown
+    def show_plugin_config
+      name, type = @show_plugin_config.split(":") # input:tail
+      $log.info "show_plugin_config option is deprecated. Use fluent-plugin-config-format --format=txt #{name} #{type}"
+      exit 0
     end
 
-    def supervise(&block)
-      start_time = Time.now
+    def supervise
+      # Make dumpable conf, which is set corresponding_proxies for all elements in all worker sections
+      dry_run
 
       Process.setproctitle("supervisor:#{@process_name}") if @process_name
-      $log.info "starting fluentd-#{Fluent::VERSION}"
-      @main_pid = fork do
-        main_process(&block)
-      end
-
-      if @daemonize && @wait_daemonize_pipe_w
-        STDIN.reopen("/dev/null")
-        STDOUT.reopen("/dev/null", "w")
-        STDERR.reopen("/dev/null", "w")
-        @wait_daemonize_pipe_w.close
-        @wait_daemonize_pipe_w = nil
-      end
-
-      Process.waitpid(@main_pid)
-      @main_pid = nil
-      ecode = $?.to_i
-
-      $log.info "process finished", code: ecode
-
-      if !@finished && Time.now - start_time < 1
-        $log.warn "process died within 1 second. exit."
-        exit ecode
-      end
+      $log.info "starting fluentd-#{Fluent::VERSION}", pid: Process.pid, ruby: RUBY_VERSION
+
+      rubyopt = ENV["RUBYOPT"]
+      fluentd_spawn_cmd = [ServerEngine.ruby_bin_path, "-Eascii-8bit:ascii-8bit"]
+      fluentd_spawn_cmd << rubyopt if rubyopt
+      fluentd_spawn_cmd << $0
+      fluentd_spawn_cmd += $fluentdargv
+      fluentd_spawn_cmd << "--under-supervisor"
+
+      $log.info "spawn command to main: ", cmdline: fluentd_spawn_cmd
+
+      params = {}
+      params['main_cmd'] = fluentd_spawn_cmd
+      params['daemonize'] = @daemonize
+      params['inline_config'] = @inline_config
+      params['log_path'] = @log_path
+      params['log_rotate_age'] = @log_rotate_age
+      params['log_rotate_size'] = @log_rotate_size
+      params['chuser'] = @chuser
+      params['chgroup'] = @chgroup
+      params['use_v1_config'] = @use_v1_config
+      params['conf_encoding'] = @conf_encoding
+
+      # system config parameters
+      params['workers'] = @workers
+      params['root_dir'] = @root_dir
+      params['log_level'] = @log_level
+      params['suppress_repeated_stacktrace'] = @suppress_repeated_stacktrace
+      params['signame'] = @signame
+
+      se = ServerEngine.create(ServerModule, WorkerModule){
+        Fluent::Supervisor.load_config(@config_path, params)
+      }
+      se.run
     end
 
-    def main_process(&block)
-      Process.setproctitle("worker:#{@process_name}") if @process_name
-
-      begin
-        block.call
+    def install_main_process_signal_handlers
+      # Fluentd worker process (worker of ServerEngine) don't use code in serverengine to set signal handlers,
+      # because it does almost nothing.
+      # This method is the only method to set signal handlers in Fluentd worker process.
 
-      rescue Fluent::ConfigError
-        $log.error "config error", file: @config_path, error: $!.to_s
-        $log.debug_backtrace
-        unless @log.stdout?
-          console = Fluent::Log.new(STDOUT, @log_level).enable_debug
-          console.error "config error", file: @config_path, error: $!.to_s
-          console.debug_backtrace
-        end
+      # When user use Ctrl + C not SIGINT, SIGINT is sent to all process in same process group.
+      # ServerEngine server process will send SIGTERM to child(spawned) processes by that SIGINT, so
+      # worker process SHOULD NOT do anything with SIGINT, SHOULD just ignore.
+      trap :INT do
+        $log.debug "fluentd main process get SIGINT"
 
-      rescue
-        $log.error "unexpected error", error: $!.to_s
-        $log.error_backtrace
-        unless @log.stdout?
-          console = Fluent::Log.new(STDOUT, @log_level).enable_debug
-          console.error "unexpected error", error: $!.to_s
-          console.error_backtrace
+        # When Fluentd is launched without supervisor, worker should handle ctrl-c by itself
+        if @standalone_worker
+          @finished = true
+          $log.debug "getting start to shutdown main process"
+          Fluent::Engine.stop
         end
       end
 
-      exit! 1
-    end
-
-    def install_supervisor_signal_handlers
-      trap :INT do
-        $log.debug "fluentd supervisor process get SIGINT"
-        supervisor_sigint_handler
-      end
-
       trap :TERM do
-        $log.debug "fluentd supervisor process get SIGTERM"
-        supervisor_sigterm_handler
-      end
-
-      trap :HUP do
-        $log.debug "fluentd supervisor process get SIGHUP"
-        $log.info "restarting"
-        supervisor_sighup_handler
-      end
-
-      trap :USR1 do
-        $log.debug "fluentd supervisor process get SIGUSR1"
-        supervisor_sigusr1_handler
-      end
-    end
-
-    def supervisor_sigint_handler
-      @finished = true
-      if pid = @main_pid
-        # kill processes only still exists
-        unless Process.waitpid(pid, Process::WNOHANG)
-          begin
-            Process.kill(:INT, pid)
-          rescue Errno::ESRCH
-            # ignore processes already died
-          end
+        $log.debug "fluentd main process get SIGTERM"
+        unless @finished
+          @finished = true
+          $log.debug "getting start to shutdown main process"
+          Fluent::Engine.stop
         end
       end
-    end
 
-    def supervisor_sigterm_handler
-      @finished = true
-      if pid = @main_pid
-        # kill processes only still exists
-        unless Process.waitpid(pid, Process::WNOHANG)
-          begin
-            Process.kill(:TERM, pid)
-          rescue Errno::ESRCH
-            # ignore processes already died
+      trap :USR1 do
+        flush_buffer
+      end unless Fluent.windows?
+
+      if Fluent.windows?
+        command_pipe = STDIN.dup
+        STDIN.reopen(File::NULL, "rb")
+        command_pipe.binmode
+        command_pipe.sync = true
+
+        Thread.new do
+          loop do
+            cmd = command_pipe.gets.chomp
+            case cmd
+            when "GRACEFUL_STOP", "IMMEDIATE_STOP"
+              $log.debug "fluentd main process get #{cmd} command"
+              @finished = true
+              $log.debug "getting start to shutdown main process"
+              Fluent::Engine.stop
+              break
+            else
+              $log.warn "fluentd main process get unknown command [#{cmd}]"
+            end
           end
         end
       end
     end
 
-    def supervisor_sighup_handler
+    def flush_buffer
       # Creating new thread due to mutex can't lock
       # in main thread during trap context
       Thread.new {
-        read_config
-        set_system_config
-        if pid = @main_pid
-          Process.kill(:TERM, pid)
-          # don't resuce Erro::ESRSH here (invalid status)
+        begin
+          $log.debug "fluentd main process get SIGUSR1"
+          $log.info "force flushing buffered events"
+          @log.reopen!
+          Fluent::Engine.flush!
+          $log.debug "flushing thread: flushed"
+        rescue Exception => e
+          $log.warn "flushing thread error: #{e}"
         end
       }.run
     end
 
-    def supervisor_sigusr1_handler
-      @log.reopen!
-      if pid = @main_pid
-        Process.kill(:USR1, pid)
-        # don't resuce Erro::ESRSH here (invalid status)
+    def logging_with_console_output
+      yield $log
+      unless @log.stdout?
+        logger = ServerEngine::DaemonLogger.new(STDOUT)
+        log = Fluent::Log.new(logger)
+        log.level = @log_level
+        console = log.enable_debug
+        yield console
       end
     end
 
-    def supervisor_dump_config_handler
-      $log.info @conf.to_s
-    end
+    def main_process(&block)
+      if @process_name
+        if @workers > 1
+          Process.setproctitle("worker:#{@process_name}#{ENV['SERVERENGINE_WORKER_ID']}")
+        else
+          Process.setproctitle("worker:#{@process_name}")
+        end
+      end
 
-    def supervisor_get_dump_config_handler
-      {conf: @conf.to_s}
+      unrecoverable_error = false
+
+      begin
+        block.call
+      rescue Fluent::ConfigError => e
+        logging_with_console_output do |log|
+          log.error "config error", file: @config_path, error: e
+          log.debug_backtrace
+        end
+        unrecoverable_error = true
+      rescue Fluent::UnrecoverableError => e
+        logging_with_console_output do |log|
+          log.error e.message, error: e
+          log.error_backtrace
+        end
+        unrecoverable_error = true
+      rescue ScriptError => e # LoadError, NotImplementedError, SyntaxError
+        logging_with_console_output do |log|
+          if e.respond_to?(:path)
+            log.error e.message, path: e.path, error: e
+          else
+            log.error e.message, error: e
+          end
+          log.error_backtrace
+        end
+        unrecoverable_error = true
+      rescue => e
+        logging_with_console_output do |log|
+          log.error "unexpected error", error: e
+          log.error_backtrace
+        end
+      end
+
+      exit!(unrecoverable_error ? 2 : 1)
     end
 
     def read_config
-      $log.info "reading config file", path: @config_path
       @config_fname = File.basename(@config_path)
       @config_basedir = File.dirname(@config_path)
-      @config_data = File.read(@config_path)
+      @config_data = File.open(@config_path, "r:#{@conf_encoding}:utf-8") {|f| f.read }
       if @inline_config == '-'
         @config_data << "\n" << STDIN.read
       elsif @inline_config
@@ -482,28 +777,12 @@ module Fluent
 
     def set_system_config
       @system_config = SystemConfig.create(@conf) # @conf is set in read_config
+      @system_config.attach(self)
       @system_config.apply(self)
     end
 
-    def run_configure
-      Fluent::Engine.run_configure(@conf)
-    end
-
     def change_privilege
-      if @chgroup
-        etc_group = Supervisor.get_etc_group(@chgroup)
-        Process::GID.change_privilege(etc_group.gid)
-      end
-
-      if @chuser
-        etc_pw = Supervisor.get_etc_passwd(@chuser)
-        user_groups = [etc_pw.gid]
-        Etc.setgrent
-        Etc.group { |gr| user_groups << gr.gid if gr.mem.include?(etc_pw.name) } # emulate 'id -G'
-
-        Process.groups = Process.groups | user_groups
-        Process::UID.change_privilege(etc_pw.uid)
-      end
+      ServerEngine::Privilege.change(@chuser, @chgroup)
     end
 
     def init_engine
@@ -516,54 +795,13 @@ module Fluent
       @plugin_dirs.each {|dir|
         if Dir.exist?(dir)
           dir = File.expand_path(dir)
-          Fluent::Engine.load_plugin_dir(dir)
+          Fluent::Engine.add_plugin_dir(dir)
         end
       }
     end
 
-    def install_main_process_signal_handlers
-      # Strictly speaking, these signal handling is not thread safe.
-      # But enough safe to limit twice call of Fluent::Engine.stop.
-
-      trap :INT do
-        $log.debug "fluentd main process get SIGINT"
-        unless @finished
-          @finished = true
-          $log.debug "getting start to shutdown main process"
-          Fluent::Engine.stop
-        end
-      end
-
-      trap :TERM do
-        $log.debug "fluentd main process get SIGTERM"
-        unless @finished
-          @finished = true
-          $log.debug "getting start to shutdown main process"
-          Fluent::Engine.stop
-        end
-      end
-
-      trap :HUP do
-        # TODO
-        $log.debug "fluentd main process get SIGHUP"
-      end
-
-      trap :USR1 do
-        $log.debug "fluentd main process get SIGUSR1"
-        $log.info "force flushing buffered events"
-        @log.reopen!
-
-        # Creating new thread due to mutex can't lock
-        # in main thread during trap context
-        Thread.new {
-          begin
-            Fluent::Engine.flush!
-            $log.debug "flushing thread: flushed"
-          rescue Exception => e
-            $log.warn "flushing thread error: #{e}"
-          end
-        }.run
-      end
+    def run_configure
+      Fluent::Engine.run_configure(@conf)
     end
 
     def run_engine