fluentd 0.14.10-x86-mingw32 → 0.14.11-x86-mingw32

data/lib/fluent/plugin_helper/storage.rb

@@ -30,6 +30,10 @@ module Fluent
       StorageState = Struct.new(:storage, :running)
 
       def storage_create(usage: '', type: nil, conf: nil, default_type: nil)
+        if conf && !conf.arg.empty?
+          usage = conf.arg
+        end
+
         s = @_storages[usage]
         if s && s.running
           return s.storage
@@ -72,7 +76,7 @@ module Fluent
       module StorageParams
         include Fluent::Configurable
         # minimum section definition to instantiate storage plugin instances
-        config_section :storage, required: false, multi: true, param_name: :storage_configs do
+        config_section :storage, required: false, multi: true, param_name: :storage_configs, init: true do
           config_argument :usage, :string, default: ''
           config_param    :@type, :string, default: Fluent::Plugin::Storage::DEFAULT_TYPE
         end
@@ -194,6 +198,10 @@ module Fluent
         def_delegators :@storage, :start, :stop, :before_shutdown, :shutdown, :after_shutdown, :close, :terminate
         def_delegators :@storage, :started?, :stopped?, :before_shutdown?, :shutdown?, :after_shutdown?, :closed?, :terminated?
 
+        def method_missing(name, *args)
+          @monitor.synchronize{ @storage.__send__(name, *args) }
+        end
+
         def persistent_always?
           true
         end
@@ -274,7 +282,7 @@ module Fluent
 
         def initialize(storage)
           @storage = storage
-          @mutex = Mutex.new
+          @monitor = Monitor.new
         end
 
         def_delegators :@storage, :persistent, :autosave, :autosave_interval, :save_at_shutdown
@@ -282,6 +290,10 @@ module Fluent
         def_delegators :@storage, :start, :stop, :before_shutdown, :shutdown, :after_shutdown, :close, :terminate
         def_delegators :@storage, :started?, :stopped?, :before_shutdown?, :shutdown?, :after_shutdown?, :closed?, :terminated?
 
+        def method_missing(name, *args)
+          @monitor.synchronize{ @storage.__send__(name, *args) }
+        end
+
         def synchronized?
           true
         end
@@ -291,35 +303,35 @@ module Fluent
         end
 
         def load
-          @mutex.synchronize do
+          @monitor.synchronize do
             @storage.load
           end
         end
 
         def save
-          @mutex.synchronize do
+          @monitor.synchronize do
             @storage.save
           end
         end
 
         def get(key)
-          @mutex.synchronize{ @storage.get(key) }
+          @monitor.synchronize{ @storage.get(key) }
         end
 
         def fetch(key, defval)
-          @mutex.synchronize{ @storage.fetch(key, defval) }
+          @monitor.synchronize{ @storage.fetch(key, defval) }
         end
 
         def put(key, value)
-          @mutex.synchronize{ @storage.put(key, value) }
+          @monitor.synchronize{ @storage.put(key, value) }
         end
 
         def delete(key)
-          @mutex.synchronize{ @storage.delete(key) }
+          @monitor.synchronize{ @storage.delete(key) }
         end
 
         def update(key, &block)
-          @mutex.synchronize do
+          @monitor.synchronize do
             v = block.call(@storage.get(key))
             @storage.put(key, v)
             v

data/lib/fluent/plugin_id.rb

@@ -20,6 +20,11 @@ module Fluent
   module PluginId
     @@configured_ids = Set.new
 
+    def initialize
+      super
+      @_plugin_root_dir = nil
+    end
+
     def configure(conf)
       @id = conf['@id']
       @_id_configured = !!@id # plugin id is explicitly configured by users (or not)
@@ -59,5 +64,17 @@ module Fluent
         "object:#{object_id.to_s(16)}"
       end
     end
+
+    def plugin_root_dir
+      return @_plugin_root_dir if @_plugin_root_dir
+      return nil unless system_config.root_dir
+      return nil unless plugin_id_configured?
+
+      # Fluent::Plugin::Base#fluentd_worker_id
+      dir = File.join(system_config.root_dir, "worker#{fluentd_worker_id}", plugin_id)
+      FileUtils.mkdir_p(dir) unless Dir.exist?(dir)
+      @_plugin_root_dir = dir.freeze
+      dir
+    end
   end
 end

data/lib/fluent/supervisor.rb

@@ -16,10 +16,12 @@
 
 require 'etc'
 require 'fcntl'
+require 'fileutils'
 
 require 'fluent/config'
 require 'fluent/env'
 require 'fluent/engine'
+require 'fluent/error'
 require 'fluent/log'
 require 'fluent/plugin'
 require 'fluent/rpc'
@@ -191,7 +193,10 @@ module Fluent
   module WorkerModule
     def spawn(process_manager)
       main_cmd = config[:main_cmd]
-      @pm = process_manager.spawn(main_cmd)
+      env = {
+        'SERVERENGINE_WORKER_ID' => @worker_id.to_i.to_s,
+      }
+      @pm = process_manager.spawn(env, *main_cmd)
     end
 
     def after_start
@@ -225,6 +230,7 @@ module Fluent
       fluentd_conf = Fluent::Config.parse(config_data, config_fname, config_basedir, params['use_v1_config'])
       system_config = SystemConfig.create(fluentd_conf)
 
+      root_dir = system_config.root_dir || params['root_dir']
       log_level = system_config.log_level || params['log_level']
       suppress_repeated_stacktrace = system_config.suppress_repeated_stacktrace || params['suppress_repeated_stacktrace']
       log_path = params['log_path']
@@ -263,6 +269,7 @@ module Fluent
           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,
@@ -364,6 +371,7 @@ module Fluent
         setup_path: nil,
         chuser: nil,
         chgroup: nil,
+        root_dir: nil,
         suppress_interval: 0,
         suppress_repeated_stacktrace: true,
         without_source: false,
@@ -392,6 +400,7 @@ module Fluent
       @rpc_server = nil
       @process_name = nil
 
+      @root_dir = opt[:root_dir]
       @log_level = opt[:log_level]
       @log_rotate_age = opt[:log_rotate_age]
       @log_rotate_size = opt[:log_rotate_size]
@@ -416,6 +425,20 @@ module Fluent
       read_config
       set_system_config
 
+      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
+        end
+      end
+
       dry_run if @dry_run
       supervise
     end
@@ -425,7 +448,8 @@ 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
 
@@ -444,7 +468,7 @@ module Fluent
 
       install_main_process_signal_handlers
 
-      $log.info "starting fluentd-#{Fluent::VERSION} without supervision"
+      $log.info "starting fluentd-#{Fluent::VERSION} without supervision", pid: Process.pid
 
       main_process do
         create_socket_manager if @standalone_worker
@@ -501,28 +525,17 @@ module Fluent
     end
 
     def supervise
-      $log.info "starting fluentd-#{Fluent::VERSION}"
+      Process.setproctitle("supervisor:#{@process_name}") if @process_name
+      $log.info "starting fluentd-#{Fluent::VERSION}", pid: Process.pid
 
       rubyopt = ENV["RUBYOPT"]
-      if Fluent.windows?
-        # Shellwords doesn't work on windows, then used gsub for adapting space char instead of Shellwords
-        fluentd_spawn_cmd = ServerEngine.ruby_bin_path + " -Eascii-8bit:ascii-8bit "
-        fluentd_spawn_cmd << ' "' + rubyopt.gsub('"', '""') + '" ' if rubyopt
-        fluentd_spawn_cmd << ' "' + $0.gsub('"', '""') + '" '
-        $fluentdargv.each{|a|
-          fluentd_spawn_cmd << ('"' + a.gsub('"', '""') + '" ')
-        }
-      else
-        fluentd_spawn_cmd = ServerEngine.ruby_bin_path + " -Eascii-8bit:ascii-8bit "
-        fluentd_spawn_cmd << ' ' + rubyopt + ' ' if rubyopt
-        fluentd_spawn_cmd << $0.shellescape + ' '
-        $fluentdargv.each{|a|
-          fluentd_spawn_cmd << (a.shellescape + " ")
-        }
-      end
+      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"
 
-      fluentd_spawn_cmd << ("--under-supervisor")
-      $log.info "spawn command to main: " + fluentd_spawn_cmd
+      $log.info "spawn command to main: ", cmdline: fluentd_spawn_cmd
 
       params = {}
       params['main_cmd'] = fluentd_spawn_cmd
@@ -617,39 +630,54 @@ module Fluent
       }.run
     end
 
+    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 main_process(&block)
       Process.setproctitle("worker:#{@process_name}") if @process_name
 
-      configuration_error = false
+      unrecoverable_error = false
 
       begin
         block.call
-      rescue Fluent::ConfigError
-        $log.error "config error", file: @config_path, error: $!.to_s
-        $log.debug_backtrace
-        unless @log.stdout?
-          logger = ServerEngine::DaemonLogger.new(STDOUT)
-          log = Fluent::Log.new(logger)
-          log.level = @log_level
-          console = log.enable_debug
-          console.error "config error", file: @config_path, error: $!.to_s
-          console.debug_backtrace
+      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
-        configuration_error = true
-      rescue
-        $log.error "unexpected error", error: $!.to_s
-        $log.error_backtrace
-        unless @log.stdout?
-          logger = ServerEngine::DaemonLogger.new(STDOUT)
-          log = Fluent::Log.new(logger)
-          log.level = @log_level
-          console = log.enable_debug
-          console.error "unexpected error", error: $!.to_s
-          console.error_backtrace
+        unrecoverable_error = true
+      rescue => e
+        logging_with_console_output do |log|
+          log.error "unexpected error", error: e
+          log.error_backtrace
         end
       end
 
-      exit!(configuration_error ? 2 : 1)
+      exit!(unrecoverable_error ? 2 : 1)
     end
 
     def read_config

data/lib/fluent/system_config.rb

@@ -21,6 +21,14 @@ module Fluent
   class SystemConfig
     include Configurable
 
+    SYSTEM_CONFIG_PARAMETERS = [
+      :root_dir, :log_level,
+      :suppress_repeated_stacktrace, :emit_error_log_interval, :suppress_config_dump,
+      :without_source, :rpc_endpoint, :enable_get_dump, :process_name,
+      :file_permission, :dir_permission,
+    ]
+
+    config_param :root_dir, :string, default: nil
     config_param :log_level, default: nil do |level|
       Log.str_to_level(level)
     end
@@ -68,33 +76,28 @@ module Fluent
 
     def dup
       s = SystemConfig.new
-      s.log_level = @log_level
-      s.suppress_repeated_stacktrace = @suppress_repeated_stacktrace
-      s.emit_error_log_interval = @emit_error_log_interval
-      s.suppress_config_dump = @suppress_config_dump
-      s.without_source = @without_source
-      s.rpc_endpoint = @rpc_endpoint
-      s.enable_get_dump = @enable_get_dump
-      s.process_name = @process_name
-      s.file_permission = @file_permission
-      s.dir_permission = @dir_permission
-
+      SYSTEM_CONFIG_PARAMETERS.each do |param|
+        s.__send__("#{param}=", instance_variable_get("@#{param}"))
+      end
       s
     end
 
     def apply(supervisor)
       system = self
       supervisor.instance_eval {
-        @log.level = @log_level = system.log_level unless system.log_level.nil?
-        @suppress_interval = system.emit_error_log_interval unless system.emit_error_log_interval.nil?
-        @suppress_config_dump = system.suppress_config_dump unless system.suppress_config_dump.nil?
-        @suppress_repeated_stacktrace = system.suppress_repeated_stacktrace unless system.suppress_repeated_stacktrace.nil?
-        @without_source = system.without_source unless system.without_source.nil?
-        @rpc_endpoint = system.rpc_endpoint unless system.rpc_endpoint.nil?
-        @enable_get_dump = system.enable_get_dump unless system.enable_get_dump.nil?
-        @process_name = system.process_name unless system.process_name.nil?
-        @file_permission = system.file_permission unless system.file_permission.nil?
-        @dir_permission = system.dir_permission unless system.dir_permission.nil?
+        SYSTEM_CONFIG_PARAMETERS.each do |param|
+          param_value = system.send(param)
+          next if param_value.nil?
+
+          case param
+          when :log_level
+            @log.level = @log_level = param_value
+          when :emit_error_log_interval
+            @suppress_interval = param_value
+          else
+            instance_variable_set("@#{param}", param_value)
+          end
+        end
       }
     end
 

data/lib/fluent/version.rb

@@ -16,6 +16,6 @@
 
 module Fluent
 
-  VERSION = '0.14.10'
+  VERSION = '0.14.11'
 
 end

data/test/command/test_fluentd.rb

@@ -0,0 +1,348 @@
+require_relative '../helper'
+
+# require 'fluent/command/fluentd'
+# don't require it... it runs immediately
+
+require 'fileutils'
+require 'timeout'
+
+class TestFluentdCommand < ::Test::Unit::TestCase
+  TMP_DIR = File.expand_path(File.dirname(__FILE__) + "/../tmp/command/fluentd#{ENV['TEST_ENV_NUMBER']}")
+  SUPERVISOR_PID_PATTERN = /starting fluentd-[.0-9]+ pid=(\d+)/
+  WORKER_PID_PATTERN = /starting fluentd worker pid=(\d+) /
+
+  setup do
+    FileUtils.rm_rf(TMP_DIR)
+    FileUtils.mkdir_p(TMP_DIR)
+    @supervisor_pid = nil
+    @worker_pids = []
+  end
+
+  def process_exist?(pid)
+    begin
+      r = Process.waitpid(pid, Process::WNOHANG)
+      return true if r.nil?
+      false
+    rescue SystemCallError
+      false
+    end
+  end
+
+  def create_conf_file(name, content)
+    conf_path = File.join(TMP_DIR, name)
+    File.open(conf_path, 'w') do |file|
+      file.write content
+    end
+    conf_path
+  end
+
+  def create_plugin_file(name, content)
+    file_path = File.join(TMP_DIR, 'plugin', name)
+    FileUtils.mkdir_p(File.dirname(file_path))
+    File.open(file_path, 'w') do |file|
+      file.write content
+    end
+    file_path
+  end
+
+  def create_cmdline(conf_path, *fluentd_options)
+    cmd_path = File.expand_path(File.dirname(__FILE__) + "../../../bin/fluentd")
+    ["bundle", "exec", "ruby", cmd_path, "-c", conf_path, *fluentd_options]
+  end
+
+  def execute_command(cmdline, chdir=TMP_DIR)
+    null_stream = File.open(File::NULL, 'w')
+    gemfile_path = File.expand_path(File.dirname(__FILE__) + "../../../Gemfile")
+
+    env = {
+      "BUNDLE_GEMFILE" => gemfile_path,
+    }
+    cmdname = cmdline.shift
+    arg0 = "testing-fluentd"
+    # p(here: "executing process", env: env, cmdname: cmdname, arg0: arg0, args: cmdline)
+    IO.popen(env, [[cmdname, arg0], *cmdline], chdir: chdir, err: [:child, :out]) do |io|
+      pid = io.pid
+      begin
+        yield pid, io
+        # p(here: "execute command", pid: pid, worker_pids: @worker_pids)
+      ensure
+        Process.kill(:KILL, pid) rescue nil
+        if @supervisor_pid
+          Process.kill(:KILL, @supervisor_pid) rescue nil
+        end
+        @worker_pids.each do |cpid|
+          Process.kill(:KILL, cpid) rescue nil
+        end
+        # p(here: "execute command", pid: pid, exist: process_exist?(pid), worker_pids: @worker_pids, exists: @worker_pids.map{|i| process_exist?(i) })
+        Timeout.timeout(10){ sleep 0.1 while process_exist?(pid) }
+      end
+    end
+  ensure
+    null_stream.close rescue nil
+  end
+
+  def assert_log_matches(cmdline, *pattern_list, timeout: 10)
+    matched = false
+    assert_error_msg = "matched correctly"
+    stdio_buf = ""
+    begin
+      execute_command(cmdline) do |pid, stdout|
+        begin
+          waiting(timeout) do
+            while process_exist?(pid) && !matched
+              readables, _, _ = IO.select([stdout], nil, nil, 1)
+              next unless readables
+              break if readables.first.eof?
+
+              buf = readables.first.readpartial(1024)
+              # puts buf
+              stdio_buf << buf
+              lines = stdio_buf.split("\n")
+              if pattern_list.all?{|ptn| lines.any?{|line| ptn.is_a?(Regexp) ? ptn.match(line) : line.include?(ptn) } }
+                matched = true
+              end
+            end
+          end
+        ensure
+          if SUPERVISOR_PID_PATTERN =~ stdio_buf
+            @supervisor_pid = $1.to_i
+          end
+          stdio_buf.scan(WORKER_PID_PATTERN) do |worker_pid|
+            @worker_pids << worker_pid.first.to_i
+          end
+        end
+      end
+    rescue Timeout::Error
+      assert_error_msg = "execution timeout with command out:\n" + stdio_buf
+    rescue => e
+      assert_error_msg = "unexpected error in launching fluentd: #{e.inspect}\n" + stdio_buf
+    end
+    assert matched, assert_error_msg
+  end
+
+  def assert_fluentd_fails_to_start(cmdline, *pattern_list, timeout: 10)
+    # empty_list.all?{ ... } is always true
+    matched = false
+    running = false
+    assert_error_msg = "failed to start correctly"
+    stdio_buf = ""
+    begin
+      execute_command(cmdline) do |pid, stdout|
+        begin
+          waiting(timeout) do
+            while process_exist?(pid) && !running
+              readables, _, _ = IO.select([stdout], nil, nil, 1)
+              next unless readables
+              next if readables.first.eof?
+
+              stdio_buf << readables.first.readpartial(1024)
+              lines = stdio_buf.split("\n")
+              if lines.any?{|line| line.include?("fluentd worker is now running") }
+                running = true
+              end
+              if pattern_list.all?{|ptn| lines.any?{|line| ptn.is_a?(Regexp) ? ptn.match(line) : line.include?(ptn) } }
+                matched = true
+              end
+            end
+          end
+        ensure
+          if SUPERVISOR_PID_PATTERN =~ stdio_buf
+            @supervisor_pid = $1.to_i
+          end
+          stdio_buf.scan(WORKER_PID_PATTERN) do |worker_pid|
+            @worker_pids << worker_pid.first.to_i
+          end
+        end
+      end
+    rescue Timeout::Error
+      assert_error_msg = "execution timeout with command out:\n" + stdio_buf
+    rescue => e
+      assert_error_msg = "unexpected error in launching fluentd: #{e.inspect}\n" + stdio_buf
+      assert false, assert_error_msg
+    end
+    assert !running, "fluentd started to run incorrectly:\n" + stdio_buf
+    unless matched
+      assert_error_msg = "fluentd failed to start, without specified regular expressions:\n" + stdio_buf
+    end
+    assert matched, assert_error_msg
+  end
+
+  sub_test_case 'with valid configuration' do
+    test 'runs successfully' do
+      conf = <<CONF
+<source>
+  @type dummy
+  @id dummy
+  @label @dummydata
+  tag dummy
+  dummy {"message": "yay!"}
+</source>
+<label @dummydata>
+  <match dummy>
+    @type null
+    @id   blackhole
+  </match>
+</label>
+CONF
+      conf_path = create_conf_file('valid.conf', conf)
+      assert File.exist?(conf_path)
+
+      assert_log_matches(create_cmdline(conf_path), "fluentd worker is now running", 'worker="0"')
+    end
+  end
+
+  sub_test_case 'with system configuration about root directory' do
+    setup do
+      @root_path = File.join(TMP_DIR, "rootpath")
+      FileUtils.rm_rf(@root_path)
+      @conf = <<CONF
+<system>
+  root_dir #{@root_path}
+</system>
+<source>
+  @type dummy
+  @id dummy
+  @label @dummydata
+  tag dummy
+  dummy {"message": "yay!"}
+</source>
+<label @dummydata>
+  <match dummy>
+    @type null
+    @id   blackhole
+  </match>
+</label>
+CONF
+    end
+
+    test 'use the specified existing directory as root' do
+      FileUtils.mkdir_p(@root_path)
+      conf_path = create_conf_file('existing_root_dir.conf', @conf)
+      assert Dir.exist?(@root_path)
+
+      assert_log_matches(create_cmdline(conf_path), "fluentd worker is now running", 'worker="0"')
+    end
+
+    test 'creates the specified root directory if missing' do
+      conf_path = create_conf_file('missing_root_dir.conf', @conf)
+      assert_false Dir.exist?(@root_path)
+
+      assert_log_matches(create_cmdline(conf_path), "fluentd worker is now running", 'worker="0"')
+      assert Dir.exist?(@root_path)
+    end
+
+    test 'fails to launch fluentd if specified root path is invalid path for directory' do
+      File.open(@root_path, 'w') do |_|
+        # create file and close it
+      end
+      conf_path = create_conf_file('existing_root_dir.conf', @conf)
+
+      assert_fluentd_fails_to_start(
+        create_cmdline(conf_path),
+        "non directory entry exists:#{@root_path} (Fluent::InvalidRootDirectory)",
+      )
+    end
+  end
+
+  sub_test_case 'configuration with wrong plugin type' do
+    test 'failed to start' do
+      conf = <<CONF
+<source>
+  @type
+  @id dummy
+  @label @dummydata
+  tag dummy
+  dummy {"message": "yay!"}
+</source>
+<label @dummydata>
+  <match dummy>
+    @type null
+    @id   blackhole
+  </match>
+</label>
+CONF
+      conf_path = create_conf_file('type_missing.conf', conf)
+      assert File.exist?(conf_path)
+
+      assert_fluentd_fails_to_start(
+        create_cmdline(conf_path),
+        "config error",
+        "error=\"Unknown input plugin ''. Run 'gem search -rd fluent-plugin' to find plugins",
+      )
+    end
+  end
+
+  sub_test_case 'configuration to load plugin file with syntax error' do
+    test 'failed to start' do
+      script =  "require 'fluent/plugin/input'\n"
+      script << "module Fluent::Plugin\n"
+      script << "  class BuggyInput < Input\n"
+      script << "    Fluent::Plugin.register_input('buggy', self)\n"
+      script << "  end\n"
+      plugin_path = create_plugin_file('in_buggy.rb', script)
+
+      conf = <<CONF
+<source>
+  @type buggy
+  @id dummy
+  @label @dummydata
+  tag dummy
+  dummy {"message": "yay!"}
+</source>
+<label @dummydata>
+  <match dummy>
+    @type null
+    @id   blackhole
+  </match>
+</label>
+CONF
+      conf_path = create_conf_file('buggy_plugin.conf', conf)
+      assert File.exist?(conf_path)
+
+      assert_fluentd_fails_to_start(
+        create_cmdline(conf_path, "-p", File.dirname(plugin_path)),
+        "error_class=SyntaxError",
+        "in_buggy.rb:5: syntax error, unexpected end-of-input, expecting keyword_end",
+      )
+    end
+  end
+
+  sub_test_case 'configuration to load plugin which raises unrecoverable error in #start' do
+    test 'failed to start' do
+      script =  "require 'fluent/plugin/input'\n"
+      script << "require 'fluent/error'\n"
+      script << "module Fluent::Plugin\n"
+      script << "  class CrashingInput < Input\n"
+      script << "    Fluent::Plugin.register_input('crashing', self)\n"
+      script << "    def start\n"
+      script << "      raise Fluent::UnrecoverableError"
+      script << "    end\n"
+      script << "  end\n"
+      script << "end\n"
+      plugin_path = create_plugin_file('in_crashing.rb', script)
+
+      conf = <<CONF
+<source>
+  @type crashing
+  @id dummy
+  @label @dummydata
+  tag dummy
+  dummy {"message": "yay!"}
+</source>
+<label @dummydata>
+  <match dummy>
+    @type null
+    @id   blackhole
+  </match>
+</label>
+CONF
+      conf_path = create_conf_file('crashing_plugin.conf', conf)
+      assert File.exist?(conf_path)
+
+      assert_fluentd_fails_to_start(
+        create_cmdline(conf_path, "-p", File.dirname(plugin_path)),
+        'unexpected error error_class=Fluent::UnrecoverableError error="an unrecoverable error occurs in Fluentd process"',
+      )
+    end
+  end
+end