fluentd 1.15.3-x86-mingw32 → 1.16.2-x86-mingw32

data/test/test_supervisor.rb

@@ -10,6 +10,7 @@ require 'uri'
 require 'fileutils'
 require 'tempfile'
 require 'securerandom'
+require 'pathname'
 
 if Fluent.windows?
   require 'win32/event'
@@ -29,12 +30,15 @@ class SupervisorTest < ::Test::Unit::TestCase
   end
 
   def setup
+    @stored_global_logger = $log
     @tmp_dir = tmp_dir
     @tmp_root_dir = File.join(@tmp_dir, 'root')
     FileUtils.mkdir_p(@tmp_dir)
+    @sigdump_path = "/tmp/sigdump-#{Process.pid}.log"
   end
 
   def teardown
+    $log = @stored_global_logger
     begin
       FileUtils.rm_rf(@tmp_dir)
     rescue Errno::EACCES
@@ -51,12 +55,11 @@ class SupervisorTest < ::Test::Unit::TestCase
 
 
   def test_system_config
-    opts = Fluent::Supervisor.default_options
-    sv = Fluent::Supervisor.new(opts)
+    sv = Fluent::Supervisor.new({})
     conf_data = <<-EOC
 <system>
   rpc_endpoint 127.0.0.1:24445
-  suppress_repeated_stacktrace true
+  suppress_repeated_stacktrace false
   suppress_config_dump true
   without_source true
   enable_get_dump true
@@ -84,7 +87,7 @@ class SupervisorTest < ::Test::Unit::TestCase
     sys_conf = sv.__send__(:build_system_config, conf)
 
     assert_equal '127.0.0.1:24445', sys_conf.rpc_endpoint
-    assert_equal true, sys_conf.suppress_repeated_stacktrace
+    assert_equal false, sys_conf.suppress_repeated_stacktrace
     assert_equal true, sys_conf.suppress_config_dump
     assert_equal true, sys_conf.without_source
     assert_equal true, sys_conf.enable_get_dump
@@ -119,8 +122,7 @@ class SupervisorTest < ::Test::Unit::TestCase
     end
 
     def test_system_config
-      opts = Fluent::Supervisor.default_options
-      sv = Fluent::Supervisor.new(opts)
+      sv = Fluent::Supervisor.new({})
       conf_data = <<-EOC
       system:
         rpc_endpoint: 127.0.0.1:24445
@@ -191,26 +193,60 @@ class SupervisorTest < ::Test::Unit::TestCase
     end
   end
 
-  def test_main_process_signal_handlers
+  def test_usr1_in_main_process_signal_handlers
     omit "Windows cannot handle signals" if Fluent.windows?
 
     create_info_dummy_logger
 
-    opts = Fluent::Supervisor.default_options
-    sv = Fluent::Supervisor.new(opts)
+    sv = Fluent::Supervisor.new({})
     sv.send(:install_main_process_signal_handlers)
 
-    begin
-      Process.kill :USR1, $$
-    rescue
-    end
+    Process.kill :USR1, Process.pid
 
     sleep 1
 
-    info_msg = '[info]: force flushing buffered events' + "\n"
+    info_msg = "[info]: force flushing buffered events\n"
     assert{ $log.out.logs.first.end_with?(info_msg) }
   ensure
-    $log.out.reset if $log && $log.out && $log.out.respond_to?(:reset)
+    $log.out.reset if $log&.out&.respond_to?(:reset)
+  end
+
+  def test_cont_in_main_process_signal_handlers
+    omit "Windows cannot handle signals" if Fluent.windows?
+
+    sv = Fluent::Supervisor.new({})
+    sv.send(:install_main_process_signal_handlers)
+
+    Process.kill :CONT, Process.pid
+
+    sleep 1
+
+    assert{ File.exist?(@sigdump_path) }
+  ensure
+    File.delete(@sigdump_path) if File.exist?(@sigdump_path)
+  end
+
+  def test_term_cont_in_main_process_signal_handlers
+    omit "Windows cannot handle signals" if Fluent.windows?
+
+    create_debug_dummy_logger
+
+    sv = Fluent::Supervisor.new({})
+    sv.send(:install_main_process_signal_handlers)
+
+    Process.kill :TERM, Process.pid
+    Process.kill :CONT, Process.pid
+
+    sleep 1
+
+    debug_msg = "[debug]: fluentd main process get SIGTERM\n"
+    logs = $log.out.logs
+    assert{ logs.any?{|log| log.include?(debug_msg) } }
+
+    assert{ not File.exist?(@sigdump_path) }
+  ensure
+    $log.out.reset if $log&.out&.respond_to?(:reset)
+    File.delete(@sigdump_path) if File.exist?(@sigdump_path)
   end
 
   def test_main_process_command_handlers
@@ -218,8 +254,7 @@ class SupervisorTest < ::Test::Unit::TestCase
 
     create_info_dummy_logger
 
-    opts = Fluent::Supervisor.default_options
-    sv = Fluent::Supervisor.new(opts)
+    sv = Fluent::Supervisor.new({})
     r, w = IO.pipe
     $stdin = r
     sv.send(:install_main_process_signal_handlers)
@@ -233,23 +268,21 @@ class SupervisorTest < ::Test::Unit::TestCase
 
     sleep 1
 
-    info_msg = '[info]: force flushing buffered events' + "\n"
+    info_msg = "[info]: force flushing buffered events\n"
     assert{ $log.out.logs.first.end_with?(info_msg) }
   ensure
-    $log.out.reset if $log && $log.out && $log.out.respond_to?(:reset)
+    $log.out.reset if $log&.out&.respond_to?(:reset)
   end
 
-  def test_supervisor_signal_handler
+  def test_usr1_in_supervisor_signal_handler
     omit "Windows cannot handle signals" if Fluent.windows?
 
     create_debug_dummy_logger
 
     server = DummyServer.new
     server.install_supervisor_signal_handlers
-    begin
-      Process.kill :USR1, $$
-    rescue
-    end
+
+    Process.kill :USR1, Process.pid
 
     sleep 1
 
@@ -257,12 +290,43 @@ class SupervisorTest < ::Test::Unit::TestCase
     logs = $log.out.logs
     assert{ logs.any?{|log| log.include?(debug_msg) } }
   ensure
-    $log.out.reset if $log && $log.out && $log.out.respond_to?(:reset)
+    $log.out.reset if $log&.out&.respond_to?(:reset)
+  end
+
+  def test_cont_in_supervisor_signal_handler
+    omit "Windows cannot handle signals" if Fluent.windows?
+
+    server = DummyServer.new
+    server.install_supervisor_signal_handlers
+
+    Process.kill :CONT, Process.pid
+
+    sleep 1
+
+    assert{ File.exist?(@sigdump_path) }
+  ensure
+    File.delete(@sigdump_path) if File.exist?(@sigdump_path)
+  end
+
+  def test_term_cont_in_supervisor_signal_handler
+    omit "Windows cannot handle signals" if Fluent.windows?
+
+    server = DummyServer.new
+    server.install_supervisor_signal_handlers
+
+    Process.kill :TERM, Process.pid
+    Process.kill :CONT, Process.pid
+
+    assert{ not File.exist?(@sigdump_path) }
+  ensure
+    File.delete(@sigdump_path) if File.exist?(@sigdump_path)
   end
 
   def test_windows_shutdown_event
     omit "Only for Windows platform" unless Fluent.windows?
 
+    create_debug_dummy_logger
+
     server = DummyServer.new
     def server.config
       {:signame => "TestFluentdEvent"}
@@ -285,7 +349,7 @@ class SupervisorTest < ::Test::Unit::TestCase
     logs = $log.out.logs
     assert{ logs.any?{|log| log.include?(debug_msg) } }
   ensure
-    $log.out.reset if $log && $log.out && $log.out.respond_to?(:reset)
+    $log.out.reset if $log&.out&.respond_to?(:reset)
   end
 
   def test_supervisor_event_handler
@@ -311,15 +375,14 @@ class SupervisorTest < ::Test::Unit::TestCase
     logs = $log.out.logs
     assert{ logs.any?{|log| log.include?(debug_msg) } }
   ensure
-    $log.out.reset if $log && $log.out && $log.out.respond_to?(:reset)
+    $log.out.reset if $log&.out&.respond_to?(:reset)
   end
 
-  data("Normal", {raw_path: "C:\\Windows\\Temp\\sigdump.log", expected: "C:\\Windows\\Temp\\sigdump-#{$$}.log"})
-  data("UNIX style", {raw_path: "/Windows/Temp/sigdump.log", expected: "/Windows/Temp/sigdump-#{$$}.log"})
-  data("No extension", {raw_path: "C:\\Windows\\Temp\\sigdump", expected: "C:\\Windows\\Temp\\sigdump-#{$$}"})
-  data("Multi-extension", {raw_path: "C:\\Windows\\Temp\\sig.dump.bk", expected: "C:\\Windows\\Temp\\sig.dump-#{$$}.bk"})
+  data("Normal", {raw_path: "C:\\Windows\\Temp\\sigdump.log", expected: "C:\\Windows\\Temp\\sigdump-#{Process.pid}.log"})
+  data("UNIX style", {raw_path: "/Windows/Temp/sigdump.log", expected: "/Windows/Temp/sigdump-#{Process.pid}.log"})
+  data("No extension", {raw_path: "C:\\Windows\\Temp\\sigdump", expected: "C:\\Windows\\Temp\\sigdump-#{Process.pid}"})
+  data("Multi-extension", {raw_path: "C:\\Windows\\Temp\\sig.dump.bk", expected: "C:\\Windows\\Temp\\sig.dump-#{Process.pid}.bk"})
   def test_fluentsigdump_get_path_with_pid(data)
-    p data
     path = Fluent::FluentSigdump.get_path_with_pid(data[:raw_path])
     assert_equal(data[:expected], path)
   end
@@ -368,8 +431,7 @@ class SupervisorTest < ::Test::Unit::TestCase
 
     create_info_dummy_logger
 
-    opts = Fluent::Supervisor.default_options
-    sv = Fluent::Supervisor.new(opts)
+    sv = Fluent::Supervisor.new({})
     conf_data = <<-EOC
   <system>
     rpc_endpoint "#{bindaddr}:24447"
@@ -386,7 +448,7 @@ class SupervisorTest < ::Test::Unit::TestCase
 
     sv.send(:install_main_process_signal_handlers)
     response = Net::HTTP.get(URI.parse("http://#{localhost}:24447/api/plugins.flushBuffers"))
-    info_msg = '[info]: force flushing buffered events' + "\n"
+    info_msg = "[info]: force flushing buffered events\n"
 
     server.stop_rpc_server
 
@@ -405,8 +467,7 @@ class SupervisorTest < ::Test::Unit::TestCase
   def test_invalid_rpc_endpoint(data)
     endpoint = data[0]
 
-    opts = Fluent::Supervisor.default_options
-    sv = Fluent::Supervisor.new(opts)
+    sv = Fluent::Supervisor.new({})
     conf_data = <<-EOC
   <system>
     rpc_endpoint "#{endpoint}"
@@ -434,8 +495,7 @@ class SupervisorTest < ::Test::Unit::TestCase
 
     create_info_dummy_logger
 
-    opts = Fluent::Supervisor.default_options
-    sv = Fluent::Supervisor.new(opts)
+    sv = Fluent::Supervisor.new({})
     conf_data = <<-EOC
   <system>
     rpc_endpoint "#{bindaddr}:24447"
@@ -462,36 +522,17 @@ class SupervisorTest < ::Test::Unit::TestCase
     assert_equal('{"ok":true}', response)
   end
 
-  def test_load_config
-    tmp_dir = "#{@tmp_dir}/dir/test_load_config.conf"
-    conf_info_str = %[
-<system>
-  log_level info
-</system>
-]
-    conf_debug_str = %[
-<system>
-  log_level debug
-</system>
-]
-    now = Time.now
-    Timecop.freeze(now)
-
-    write_config tmp_dir, conf_info_str
-
+  def test_serverengine_config
     params = {}
     params['workers'] = 1
+    params['fluentd_conf_path'] = "fluentd.conf"
     params['use_v1_config'] = true
-    params['log_path'] = 'test/tmp/supervisor/log'
-    params['suppress_repeated_stacktrace'] = true
-    params['log_level'] = Fluent::Log::LEVEL_INFO
     params['conf_encoding'] = 'utf-8'
-    load_config_proc =  Proc.new { Fluent::Supervisor.load_config(tmp_dir, params) }
+    params['log_level'] = Fluent::Log::LEVEL_INFO
+    load_config_proc =  Proc.new { Fluent::Supervisor.serverengine_config(params) }
 
-    # first call
     se_config = load_config_proc.call
     assert_equal Fluent::Log::LEVEL_INFO, se_config[:log_level]
-    assert_equal true, se_config[:suppress_repeated_stacktrace]
     assert_equal 'spawn', se_config[:worker_type]
     assert_equal 1, se_config[:workers]
     assert_equal false, se_config[:log_stdin]
@@ -499,99 +540,23 @@ class SupervisorTest < ::Test::Unit::TestCase
     assert_equal false, se_config[:log_stderr]
     assert_equal true, se_config[:enable_heartbeat]
     assert_equal false, se_config[:auto_heartbeat]
+    assert_equal "fluentd.conf", se_config[:config_path]
     assert_equal false, se_config[:daemonize]
     assert_nil se_config[:pid_path]
-
-    # second call immediately(reuse config)
-    se_config = load_config_proc.call
-    pre_config_mtime = se_config[:windows_daemon_cmdline][5]['pre_config_mtime']
-    pre_loadtime = se_config[:windows_daemon_cmdline][5]['pre_loadtime']
-    assert_nil pre_config_mtime
-    assert_nil pre_loadtime
-
-    Timecop.freeze(now + 5)
-
-    # third call after 5 seconds(don't reuse config)
-    se_config = load_config_proc.call
-    pre_config_mtime = se_config[:windows_daemon_cmdline][5]['pre_config_mtime']
-    pre_loadtime = se_config[:windows_daemon_cmdline][5]['pre_loadtime']
-    assert_not_nil pre_config_mtime
-    assert_not_nil pre_loadtime
-
-    # forth call immediately(reuse config)
-    se_config = load_config_proc.call
-    # test that pre_config_mtime and pre_loadtime are not changed from previous one because reused pre_config
-    assert_equal pre_config_mtime, se_config[:windows_daemon_cmdline][5]['pre_config_mtime']
-    assert_equal pre_loadtime, se_config[:windows_daemon_cmdline][5]['pre_loadtime']
-
-    write_config tmp_dir, conf_debug_str
-
-    # fifth call after changed conf file(don't reuse config)
-    se_config = load_config_proc.call
-    assert_equal Fluent::Log::LEVEL_INFO, se_config[:log_level]
-  ensure
-    Timecop.return
   end
 
-  def test_load_config_for_logger
-    tmp_dir = "#{@tmp_dir}/dir/test_load_config_log.conf"
-    conf_info_str = %[
-<system>
-  <log>
-    format json
-    time_format %FT%T.%L%z
-  </log>
-</system>
-]
-    write_config tmp_dir, conf_info_str
-    params = {
-      'use_v1_config' => true,
-      'conf_encoding' => 'utf8',
-      'log_level' => Fluent::Log::LEVEL_INFO,
-      'log_path' => 'test/tmp/supervisor/log',
-
-      'workers' => 1,
-      'log_format' => :json,
-      'log_time_format' => '%FT%T.%L%z',
-    }
-
-    r = Fluent::Supervisor.load_config(tmp_dir, params)
-    assert_equal :json, r[:logger].format
-    assert_equal '%FT%T.%L%z', r[:logger].time_format
-  end
-
-  def test_load_config_for_daemonize
-    tmp_dir = "#{@tmp_dir}/dir/test_load_config.conf"
-    conf_info_str = %[
-<system>
-  log_level info
-</system>
-]
-    conf_debug_str = %[
-<system>
-  log_level debug
-</system>
-]
-
-    now = Time.now
-    Timecop.freeze(now)
-
-    write_config tmp_dir, conf_info_str
-
+  def test_serverengine_config_for_daemonize
     params = {}
     params['workers'] = 1
+    params['fluentd_conf_path'] = "fluentd.conf"
     params['use_v1_config'] = true
-    params['log_path'] = 'test/tmp/supervisor/log'
-    params['suppress_repeated_stacktrace'] = true
+    params['conf_encoding'] = 'utf-8'
     params['log_level'] = Fluent::Log::LEVEL_INFO
     params['daemonize'] = './fluentd.pid'
-    params['conf_encoding'] = 'utf-8'
-    load_config_proc = Proc.new { Fluent::Supervisor.load_config(tmp_dir, params) }
+    load_config_proc = Proc.new { Fluent::Supervisor.serverengine_config(params) }
 
-    # first call
     se_config = load_config_proc.call
     assert_equal Fluent::Log::LEVEL_INFO, se_config[:log_level]
-    assert_equal true, se_config[:suppress_repeated_stacktrace]
     assert_equal 'spawn', se_config[:worker_type]
     assert_equal 1, se_config[:workers]
     assert_equal false, se_config[:log_stdin]
@@ -599,161 +564,212 @@ class SupervisorTest < ::Test::Unit::TestCase
     assert_equal false, se_config[:log_stderr]
     assert_equal true, se_config[:enable_heartbeat]
     assert_equal false, se_config[:auto_heartbeat]
+    assert_equal "fluentd.conf", se_config[:config_path]
     assert_equal true, se_config[:daemonize]
     assert_equal './fluentd.pid', se_config[:pid_path]
+  end
 
-    # second call immediately(reuse config)
-    se_config = load_config_proc.call
-    pre_config_mtime = se_config[:windows_daemon_cmdline][5]['pre_config_mtime']
-    pre_loadtime = se_config[:windows_daemon_cmdline][5]['pre_loadtime']
-    assert_nil pre_config_mtime
-    assert_nil pre_loadtime
+  sub_test_case "init logger" do
+    data(supervisor: true)
+    data(worker: false)
+    def test_init_for_logger(supervisor)
+      tmp_conf_path = "#{@tmp_dir}/dir/test_init_for_logger.conf"
+      conf_info_str = <<~EOC
+        <system>
+          log_level warn # To suppress logs
+          suppress_repeated_stacktrace false
+          ignore_repeated_log_interval 10s
+          ignore_same_log_interval 20s
+          <log>
+            format json
+            time_format %FT%T.%L%z
+          </log>
+        </system>
+      EOC
+      write_config tmp_conf_path, conf_info_str
 
-    Timecop.freeze(now + 5)
+      s = Fluent::Supervisor.new({config_path: tmp_conf_path})
+      s.configure(supervisor: supervisor)
 
-    # third call after 6 seconds(don't reuse config)
-    se_config = load_config_proc.call
-    pre_config_mtime = se_config[:windows_daemon_cmdline][5]['pre_config_mtime']
-    pre_loadtime = se_config[:windows_daemon_cmdline][5]['pre_loadtime']
-    assert_not_nil pre_config_mtime
-    assert_not_nil pre_loadtime
+      assert_equal :json, $log.format
+      assert_equal '%FT%T.%L%z', $log.time_format
+      assert_equal false, $log.suppress_repeated_stacktrace
+      assert_equal 10, $log.ignore_repeated_log_interval
+      assert_equal 20, $log.ignore_same_log_interval
+    end
 
-    # forth call immediately(reuse config)
-    se_config = load_config_proc.call
-    # test that pre_config_mtime and pre_loadtime are not changed from previous one because reused pre_config
-    assert_equal pre_config_mtime, se_config[:windows_daemon_cmdline][5]['pre_config_mtime']
-    assert_equal pre_loadtime, se_config[:windows_daemon_cmdline][5]['pre_loadtime']
+    data(
+      daily_age: 'daily',
+      weekly_age: 'weekly',
+      monthly_age: 'monthly',
+      integer_age: 2,
+    )
+    def test_logger_with_rotate_age_and_rotate_size(rotate_age)
+      config_path = "#{@tmp_dir}/empty.conf"
+      write_config config_path, ""
+
+      sv = Fluent::Supervisor.new(
+        config_path: config_path,
+        log_path: "#{@tmp_dir}/test",
+        log_rotate_age: rotate_age,
+        log_rotate_size: 10,
+      )
+      sv.__send__(:setup_global_logger)
+
+      assert_equal Fluent::LogDeviceIO, $log.out.class
+      assert_equal rotate_age, $log.out.instance_variable_get(:@shift_age)
+      assert_equal 10, $log.out.instance_variable_get(:@shift_size)
+    end
 
-    write_config tmp_dir, conf_debug_str
+    def test_can_start_with_rotate_but_no_log_path
+      config_path = "#{@tmp_dir}/empty.conf"
+      write_config config_path, ""
 
-    # fifth call after changed conf file(don't reuse config)
-    se_config = load_config_proc.call
-    assert_equal Fluent::Log::LEVEL_INFO, se_config[:log_level]
-  ensure
-    Timecop.return
-  end
+      sv = Fluent::Supervisor.new(
+        config_path: config_path,
+        log_rotate_age: 5,
+      )
+      sv.__send__(:setup_global_logger)
 
-  def test_logger
-    opts = Fluent::Supervisor.default_options
-    sv = Fluent::Supervisor.new(opts)
-    log = sv.instance_variable_get(:@log)
-    log.init(:standalone, 0)
-    logger = $log.instance_variable_get(:@logger)
+      assert_true $log.stdout?
+    end
 
-    assert_equal Fluent::Log::LEVEL_INFO, $log.level
+    sub_test_case "system log rotation" do
+      def parse_text(text)
+        basepath = File.expand_path(File.dirname(__FILE__) + '/../../')
+        Fluent::Config.parse(text, '(test)', basepath, true).elements.find { |e| e.name == 'system' }
+      end
 
-    # test that DamonLogger#level= overwrites Fluent.log#level
-    logger.level = 'debug'
-    assert_equal Fluent::Log::LEVEL_DEBUG, $log.level
+      def test_override_default_log_rotate
+        Tempfile.open do |file|
+          config = parse_text(<<-EOS)
+            <system>
+              <log>
+                rotate_age 3
+                rotate_size 300
+              </log>
+            </system>
+          EOS
+          file.puts(config)
+          file.flush
+          sv = Fluent::Supervisor.new({log_path: "#{@tmp_dir}/test.log", config_path: file.path})
+
+          sv.__send__(:setup_global_logger)
+          logger = $log.instance_variable_get(:@logger)
+
+          assert_equal Fluent::LogDeviceIO, $log.out.class
+          assert_equal 3, $log.out.instance_variable_get(:@shift_age)
+          assert_equal 300, $log.out.instance_variable_get(:@shift_size)
+        end
+      end
 
-    assert_equal 5, logger.instance_variable_get(:@rotate_age)
-    assert_equal 1048576, logger.instance_variable_get(:@rotate_size)
-  end
+      def test_override_default_log_rotate_with_yaml_config
+        Tempfile.open do |file|
+          config = <<-EOS
+            system:
+              log:
+                rotate_age: 3
+                rotate_size: 300
+          EOS
+          file.puts(config)
+          file.flush
+          sv = Fluent::Supervisor.new({log_path: "#{@tmp_dir}/test.log", config_path: file.path, config_file_type: :yaml})
+
+          sv.__send__(:setup_global_logger)
+          logger = $log.instance_variable_get(:@logger)
+
+          assert_equal Fluent::LogDeviceIO, $log.out.class
+          assert_equal 3, $log.out.instance_variable_get(:@shift_age)
+          assert_equal 300, $log.out.instance_variable_get(:@shift_size)
+        end
+      end
+    end
 
-  data(
-    daily_age: 'daily',
-    weekly_age: 'weekly',
-    monthly_age: 'monthly',
-    integer_age: 2,
-  )
-  def test_logger_with_rotate_age_and_rotate_size(rotate_age)
-    opts = Fluent::Supervisor.default_options.merge(
-      log_path: "#{@tmp_dir}/test", log_rotate_age: rotate_age, log_rotate_size: 10
-    )
-    sv = Fluent::Supervisor.new(opts)
-    log = sv.instance_variable_get(:@log)
-    log.init(:standalone, 0)
+    def test_log_level_affects
+      sv = Fluent::Supervisor.new({})
 
-    assert_equal Fluent::LogDeviceIO, $log.out.class
-    assert_equal rotate_age, $log.out.instance_variable_get(:@shift_age)
-    assert_equal 10, $log.out.instance_variable_get(:@shift_size)
-  end
+      c = Fluent::Config::Element.new('system', '', { 'log_level' => 'error' }, [])
+      stub(Fluent::Config).build { config_element('ROOT', '', {}, [c]) }
 
-  sub_test_case "system log rotation" do
-    def parse_text(text)
-      basepath = File.expand_path(File.dirname(__FILE__) + '/../../')
-      Fluent::Config.parse(text, '(test)', basepath, true).elements.find { |e| e.name == 'system' }
+      sv.configure
+      assert_equal Fluent::Log::LEVEL_ERROR, $log.level
     end
 
-    def test_override_default_log_rotate
-      Tempfile.open do |file|
-        config = parse_text(<<-EOS)
-          <system>
-            <log>
-              rotate_age 3
-              rotate_size 300
-            </log>
-          </system>
-        EOS
-        file.puts(config)
-        file.flush
-        opts = Fluent::Supervisor.default_options.merge(
-          log_path: "#{@tmp_dir}/test.log", config_path: file.path
-        )
-        sv = Fluent::Supervisor.new(opts)
-
-        log = sv.instance_variable_get(:@log)
-        log.init(:standalone, 0)
-        logger = $log.instance_variable_get(:@logger)
-
-        assert_equal([3, 300],
-                     [logger.instance_variable_get(:@rotate_age),
-                      logger.instance_variable_get(:@rotate_size)])
+    data(supervisor: true)
+    data(worker: false)
+    def test_log_path(supervisor)
+      log_path = Pathname(@tmp_dir) + "fluentd.log"
+      config_path = Pathname(@tmp_dir) + "fluentd.conf"
+      write_config config_path.to_s, ""
+
+      s = Fluent::Supervisor.new(config_path: config_path.to_s, log_path: log_path.to_s)
+      assert_rr do
+        mock.proxy(File).chmod(0o777, log_path.parent.to_s).never
+        s.__send__(:setup_global_logger, supervisor: supervisor)
       end
-    end
 
-    def test_override_default_log_rotate_with_yaml_config
-      Tempfile.open do |file|
-        config = <<-EOS
-          system:
-            log:
-              rotate_age: 3
-              rotate_size: 300
-        EOS
-        file.puts(config)
-        file.flush
-        opts = Fluent::Supervisor.default_options.merge(
-          log_path: "#{@tmp_dir}/test.log", config_path: file.path, config_file_type: :yaml,
-        )
-        sv = Fluent::Supervisor.new(opts)
-
-        log = sv.instance_variable_get(:@log)
-        log.init(:standalone, 0)
-        logger = $log.instance_variable_get(:@logger)
-
-        assert_equal([3, 300],
-                     [logger.instance_variable_get(:@rotate_age),
-                      logger.instance_variable_get(:@rotate_size)])
-      end
+      assert { log_path.parent.exist? }
+    ensure
+      $log.out.close
     end
-  end
 
-  def test_inline_config
-    omit 'this feature is deprecated. see https://github.com/fluent/fluentd/issues/2711'
+    data(supervisor: true)
+    data(worker: false)
+    def test_dir_permission(supervisor)
+      omit "NTFS doesn't support UNIX like permissions" if Fluent.windows?
+
+      log_path = Pathname(@tmp_dir) + "fluentd.log"
+      config_path = Pathname(@tmp_dir) + "fluentd.conf"
+      conf = <<~EOC
+        <system>
+          dir_permission 0o777
+        </system>
+      EOC
+      write_config config_path.to_s, conf
+
+      s = Fluent::Supervisor.new(config_path: config_path.to_s, log_path: log_path.to_s)
+      assert_rr do
+        mock.proxy(File).chmod(0o777, log_path.parent.to_s).once
+        s.__send__(:setup_global_logger, supervisor: supervisor)
+      end
 
-    opts = Fluent::Supervisor.default_options
-    opts[:inline_config] = '-'
-    sv = Fluent::Supervisor.new(opts)
-    assert_equal '-', sv.instance_variable_get(:@inline_config)
+      assert { log_path.parent.exist? }
+      assert { (File.stat(log_path.parent).mode & 0xFFF) == 0o777 }
+    ensure
+      $log.out.close
+    end
 
-    inline_config = '<match *>\n@type stdout\n</match>'
-    stub(STDIN).read { inline_config }
-    stub(Fluent::Config).build                                # to skip
-    stub(sv).build_system_config { Fluent::SystemConfig.new } # to skip
+    def test_files_for_each_process_with_rotate_on_windows
+      omit "Only for Windows." unless Fluent.windows?
+
+      log_path = Pathname(@tmp_dir) + "log" + "fluentd.log"
+      config_path = Pathname(@tmp_dir) + "fluentd.conf"
+      conf = <<~EOC
+        <system>
+          <log>
+            rotate_age 5
+          </log>
+        </system>
+      EOC
+      write_config config_path.to_s, conf
 
-    sv.configure
-    assert_equal inline_config, sv.instance_variable_get(:@inline_config)
-  end
+      s = Fluent::Supervisor.new(config_path: config_path.to_s, log_path: log_path.to_s)
+      s.__send__(:setup_global_logger, supervisor: true)
+      $log.out.close
 
-  def test_log_level_affects
-    opts = Fluent::Supervisor.default_options
-    sv = Fluent::Supervisor.new(opts)
+      s = Fluent::Supervisor.new(config_path: config_path.to_s, log_path: log_path.to_s)
+      s.__send__(:setup_global_logger, supervisor: false)
+      $log.out.close
 
-    c = Fluent::Config::Element.new('system', '', { 'log_level' => 'error' }, [])
-    stub(Fluent::Config).build { config_element('ROOT', '', {}, [c]) }
+      ENV["SERVERENGINE_WORKER_ID"] = "1"
+      s = Fluent::Supervisor.new(config_path: config_path.to_s, log_path: log_path.to_s)
+      s.__send__(:setup_global_logger, supervisor: false)
+      $log.out.close
 
-    sv.configure
-    assert_equal Fluent::Log::LEVEL_ERROR, $log.level
+      assert { log_path.parent.entries.size == 5 } # [".", "..", "logfile.log", ...]
+    ensure
+      ENV.delete("SERVERENGINE_WORKER_ID")
+    end
   end
 
   def test_enable_shared_socket
@@ -787,14 +803,6 @@ class SupervisorTest < ::Test::Unit::TestCase
     end
   end
 
-  def test_per_process_path
-    path = Fluent::Supervisor::LoggerInitializer.per_process_path("C:/tmp/test.log", :supervisor, 0)
-    assert_equal(path, "C:/tmp/test-supervisor-0.log")
-
-    path = Fluent::Supervisor::LoggerInitializer.per_process_path("C:/tmp/test.log", :worker, 1)
-    assert_equal(path, "C:/tmp/test-1.log")
-  end
-
   def create_debug_dummy_logger
     dl_opts = {}
     dl_opts[:log_level] = ServerEngine::DaemonLogger::DEBUG