fluentd 0.12.43 → 0.14.0

data/test/test_plugin_helper.rb

@@ -0,0 +1,81 @@
+require_relative 'helper'
+require 'fluent/plugin_helper'
+require 'fluent/plugin/base'
+
+class ConfigTest < Test::Unit::TestCase
+  module FluentTest; end
+
+  sub_test_case 'Fluent::Plugin::Base.helpers method works as shortcut to include helper modules' do
+    class FluentTest::PluginTest1 < Fluent::Plugin::TestBase
+      helpers :event_emitter
+    end
+    class FluentTest::PluginTest2 < Fluent::Plugin::TestBase
+      helpers :thread
+    end
+    class FluentTest::PluginTest3 < Fluent::Plugin::TestBase
+      helpers :event_loop
+    end
+    class FluentTest::PluginTest4 < Fluent::Plugin::TestBase
+      helpers :timer
+    end
+    class FluentTest::PluginTest5 < Fluent::Plugin::TestBase
+      helpers :child_process
+    end
+    class FluentTest::PluginTest6 < Fluent::Plugin::TestBase
+      helpers :retry_state
+    end
+    class FluentTest::PluginTest0 < Fluent::Plugin::TestBase
+      helpers :event_emitter, :thread, :event_loop, :timer, :child_process, :retry_state
+    end
+
+    test 'plugin can include helper event_emitter' do
+      assert FluentTest::PluginTest1.include?(Fluent::PluginHelper::EventEmitter)
+      p1 = FluentTest::PluginTest1.new
+      assert p1.respond_to?(:has_router?)
+      assert p1.has_router?
+    end
+
+    test 'plugin can include helper thread' do
+      assert FluentTest::PluginTest2.include?(Fluent::PluginHelper::Thread)
+      p2 = FluentTest::PluginTest2.new
+      assert p2.respond_to?(:thread_current_running?)
+      assert p2.respond_to?(:thread_create)
+    end
+
+    test 'plugin can include helper event_loop' do
+      assert FluentTest::PluginTest3.include?(Fluent::PluginHelper::EventLoop)
+      p3 = FluentTest::PluginTest3.new
+      assert p3.respond_to?(:event_loop_attach)
+      assert p3.respond_to?(:event_loop_running?)
+    end
+
+    test 'plugin can include helper timer' do
+      assert FluentTest::PluginTest4.include?(Fluent::PluginHelper::Timer)
+      p4 = FluentTest::PluginTest4.new
+      assert p4.respond_to?(:timer_execute)
+    end
+
+    test 'plugin can include helper child_process' do
+      assert FluentTest::PluginTest5.include?(Fluent::PluginHelper::ChildProcess)
+      p5 = FluentTest::PluginTest5.new
+      assert p5.respond_to?(:child_process_execute)
+    end
+
+    test 'plugin can 2 or more helpers at once' do
+      assert FluentTest::PluginTest0.include?(Fluent::PluginHelper::EventEmitter)
+      assert FluentTest::PluginTest0.include?(Fluent::PluginHelper::Thread)
+      assert FluentTest::PluginTest0.include?(Fluent::PluginHelper::EventLoop)
+      assert FluentTest::PluginTest0.include?(Fluent::PluginHelper::Timer)
+      assert FluentTest::PluginTest0.include?(Fluent::PluginHelper::ChildProcess)
+
+      p0 = FluentTest::PluginTest0.new
+      assert p0.respond_to?(:child_process_execute)
+      assert p0.respond_to?(:timer_execute)
+      assert p0.respond_to?(:event_loop_attach)
+      assert p0.respond_to?(:event_loop_running?)
+      assert p0.respond_to?(:thread_current_running?)
+      assert p0.respond_to?(:thread_create)
+      assert p0.respond_to?(:has_router?)
+    end
+  end
+end

data/test/test_root_agent.rb

@@ -8,7 +8,7 @@ class RootAgentTest < ::Test::Unit::TestCase
   include FluentTest
 
   def test_initialize
-    ra = RootAgent.new
+    ra = RootAgent.new(log: $log)
     assert_equal 0, ra.instance_variable_get(:@suppress_emit_error_log_interval)
     assert_nil ra.instance_variable_get(:@next_emit_error_log_time)
   end
@@ -19,7 +19,7 @@ class RootAgentTest < ::Test::Unit::TestCase
     )
   def test_initialize_with_opt(data)
     opt, expected = data
-    ra = RootAgent.new(SystemConfig.new(opt))
+    ra = RootAgent.new(log: $log, system_config: SystemConfig.new(opt))
     expected.each { |k, v|
       assert_equal v, ra.instance_variable_get(k)
     }
@@ -27,7 +27,7 @@ class RootAgentTest < ::Test::Unit::TestCase
 
   sub_test_case 'configure' do
     setup do
-      @ra = RootAgent.new
+      @ra = RootAgent.new(log: $log)
       stub(Engine).root_agent { @ra }
     end
 
@@ -43,55 +43,10 @@ class RootAgentTest < ::Test::Unit::TestCase
       assert_empty ra.labels
       assert_empty ra.outputs
       assert_empty ra.filters
-      [:@started_inputs, :@started_outputs, :@started_filters].each { |k|
-        assert_empty ra.instance_variable_get(k)
-      }
       assert_nil ra.context
       assert_nil ra.error_collector
     end
 
-    test 'raises configuration error for missing type of source' do
-      conf = <<-EOC
-<source>
-</source>
-EOC
-      errmsg = "Missing '@type' parameter on <source> directive"
-      assert_raise Fluent::ConfigError.new(errmsg) do
-        configure_ra(conf)
-      end
-    end
-
-    test 'raises configuration error for missing type of match' do
-      conf = <<-EOC
-<source>
-  @type test_in
-</source>
-<match *.**>
-</match>
-EOC
-      errmsg = "Missing '@type' parameter on <match> directive"
-      assert_raise Fluent::ConfigError.new(errmsg) do
-        configure_ra(conf)
-      end
-    end
-
-    test 'raises configuration error for missing type of filter' do
-      conf = <<-EOC
-<source>
-  @type test_in
-</source>
-<filter *.**>
-</filter>
-<match *.**>
-  @type test_out
-</match>
-EOC
-      errmsg = "Missing '@type' parameter on <filter> directive"
-      assert_raise Fluent::ConfigError.new(errmsg) do
-        configure_ra(conf)
-      end
-    end
-
     test 'with plugins' do
       # check @type and type in one configuration
       conf = <<-EOC
@@ -124,9 +79,6 @@ EOC
       assert_kind_of FluentTestInput, ra.inputs.first
       assert_kind_of RelabelOutput, ra.outputs.first
       assert_kind_of FluentTestFilter, ra.filters.first
-      [:@started_inputs, :@started_outputs, :@started_filters].each { |k|
-        assert_empty ra.instance_variable_get(k)
-      }
       assert ra.error_collector
 
       %W(@test @ERROR).each { |label_symbol|
@@ -146,7 +98,7 @@ EOC
 
   sub_test_case 'start/shutdown' do
     setup do
-      @ra = RootAgent.new
+      @ra = RootAgent.new(log: $log)
       @ra.configure(Config.parse(<<-EOC, "(test)", "(test_dir)", true))
 <source>
   @type test_in

data/test/test_supervisor.rb

@@ -0,0 +1,272 @@
+require_relative 'helper'
+require 'fluent/event_router'
+require 'fluent/system_config'
+require 'fluent/supervisor'
+require_relative 'test_plugin_classes'
+
+require 'net/http'
+require 'uri'
+require 'fileutils'
+
+class SupervisorTest < ::Test::Unit::TestCase
+  include Fluent
+  include FluentTest
+  include ServerModule
+  include WorkerModule
+
+  TMP_DIR = File.dirname(__FILE__) + "/tmp/config#{ENV['TEST_ENV_NUMBER']}"
+
+  def setup
+    FileUtils.mkdir_p('test/tmp/supervisor')
+  end
+
+  def write_config(path, data)
+    FileUtils.mkdir_p(File.dirname(path))
+    File.open(path, "w") {|f| f.write data }
+  end
+
+  def test_initialize
+    opts = Fluent::Supervisor.default_options
+    sv = Fluent::Supervisor.new(opts)
+    opts.each { |k, v|
+      assert_equal v, sv.instance_variable_get("@#{k}")
+    }
+  end
+
+  def test_read_config
+    create_info_dummy_logger
+
+    tmp_dir = "#{TMP_DIR}/dir/test_read_config.conf"
+    conf_str = %[
+<source>
+  @type forward
+  @id forward_input
+</source>
+<match debug.**>
+  @type stdout
+  @id stdout_output
+</match>
+]
+    write_config tmp_dir, conf_str
+    opts = Fluent::Supervisor.default_options
+    sv = Fluent::Supervisor.new(opts)
+
+    use_v1_config = {}
+    use_v1_config['use_v1_config'] = true
+
+    sv.instance_variable_set(:@config_path, tmp_dir)
+    sv.instance_variable_set(:@use_v1_config, use_v1_config)
+    sv.send(:read_config)
+
+    conf = sv.instance_variable_get(:@conf)
+
+    elem = conf.elements.find { |e| e.name == 'source' }
+    assert_equal elem['@type'], "forward"
+    assert_equal elem['@id'], "forward_input"
+
+    elem = conf.elements.find { |e| e.name == 'match' }
+    assert_equal elem.arg, "debug.**"
+    assert_equal elem['@type'], "stdout"
+    assert_equal elem['@id'], "stdout_output"
+
+    $log.out.reset
+  end
+
+  def test_system_config
+    opts = Fluent::Supervisor.default_options
+    sv = Fluent::Supervisor.new(opts)
+    conf_data = <<-EOC
+<system>
+  rpc_endpoint 127.0.0.1:24445
+  suppress_repeated_stacktrace true
+  suppress_config_dump true
+  without_source true
+  enable_get_dump true
+  process_name "process_name"
+  log_level info
+</system>
+    EOC
+    conf = Fluent::Config.parse(conf_data, "(test)", "(test_dir)", true)
+    sv.instance_variable_set(:@conf, conf)
+    sv.send(:set_system_config)
+    sys_conf = sv.instance_variable_get(:@system_config)
+
+    assert_equal sys_conf.rpc_endpoint, '127.0.0.1:24445'
+    assert_equal sys_conf.suppress_repeated_stacktrace, true
+    assert_equal sys_conf.suppress_config_dump, true
+    assert_equal sys_conf.without_source, true
+    assert_equal sys_conf.enable_get_dump, true
+    assert_equal sys_conf.process_name, "process_name"
+    assert_equal sys_conf.log_level, 2
+  end
+
+  def test_main_process_signal_handlers
+    create_info_dummy_logger
+
+    unless Fluent.windows?
+      opts = Fluent::Supervisor.default_options
+      sv = Fluent::Supervisor.new(opts)
+      sv.send(:install_main_process_signal_handlers)
+
+      begin
+        Process.kill :USR1, $$
+      rescue
+      end
+
+      sleep 1
+
+      info_msg = '[info]: force flushing buffered events' + "\n"
+      assert{ $log.out.logs.first.end_with?(info_msg) }
+    end
+
+    $log.out.reset
+  end
+
+  def test_supervisor_signal_handler
+    create_debug_dummy_logger
+
+    unless Fluent.windows?
+
+      install_supervisor_signal_handlers
+      begin
+        Process.kill :USR1, $$
+      rescue
+      end
+
+      sleep 1
+
+      debug_msg = '[debug]: fluentd supervisor process get SIGUSR1' + "\n"
+      assert{ $log.out.logs.first.end_with?(debug_msg) }
+    end
+
+    $log.out.reset
+  end
+
+  def test_rpc_server
+    create_info_dummy_logger
+
+    unless Fluent.windows?
+      opts = Fluent::Supervisor.default_options
+      sv = Fluent::Supervisor.new(opts)
+      conf_data = <<-EOC
+  <system>
+    rpc_endpoint 0.0.0.0:24447
+  </system>
+      EOC
+      conf = Fluent::Config.parse(conf_data, "(test)", "(test_dir)", true)
+      sv.instance_variable_set(:@conf, conf)
+      sv.send(:set_system_config)
+      sys_conf = sv.instance_variable_get(:@system_config)
+      @rpc_endpoint = sys_conf.rpc_endpoint
+      @enable_get_dump = sys_conf.enable_get_dump
+
+      run_rpc_server
+
+      sv.send(:install_main_process_signal_handlers)
+      Net::HTTP.get URI.parse('http://0.0.0.0:24447/api/plugins.flushBuffers')
+      info_msg = '[info]: force flushing buffered events' + "\n"
+
+      stop_rpc_server
+
+      # In TravisCI with OSX(Xcode), it seems that can't use rpc server.
+      # This test will be passed in such environment.
+      pend unless $log.out.logs.first
+
+      assert{ $log.out.logs.first.end_with?(info_msg) }
+    end
+
+    $log.out.reset
+  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>
+]
+    write_config tmp_dir, conf_info_str
+
+    params = {}
+    params['use_v1_config'] = true
+    params['log_path'] = 'test/tmp/supervisor/log'
+    params['suppress_repeated_stacktrace'] = true
+    params['log_level'] = Fluent::Log::LEVEL_INFO
+    load_config_proc =  Proc.new { Fluent::Supervisor.load_config(tmp_dir, params) }
+
+    # first call
+    se_config = load_config_proc.call
+    assert_equal se_config[:log_level], Fluent::Log::LEVEL_INFO
+    assert_equal se_config[:suppress_repeated_stacktrace], true
+    assert_equal se_config[:worker_type], 'spawn'
+    assert_equal se_config[:workers], 1
+    assert_equal se_config[:log_stdin], false
+    assert_equal se_config[:log_stdout], false
+    assert_equal se_config[:log_stderr], false
+    assert_equal se_config[:enable_heartbeat], true
+    assert_equal se_config[:auto_heartbeat], false
+
+    # 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
+
+    sleep 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 se_config[:windows_daemon_cmdline][5]['pre_config_mtime'], pre_config_mtime
+    assert_equal se_config[:windows_daemon_cmdline][5]['pre_loadtime'], 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 se_config[:log_level], Fluent::Log::LEVEL_DEBUG
+  end
+
+  def test_logger
+    opts = Fluent::Supervisor.default_options
+    sv = Fluent::Supervisor.new(opts)
+    log = sv.instance_variable_get(:@log)
+    log.init
+    logger = $log.instance_variable_get(:@logger)
+
+    assert_equal $log.level, Fluent::Log::LEVEL_INFO
+
+    # test that DamonLogger#level= overwrites Fluent.log#level
+    logger.level = 'debug'
+    assert_equal $log.level, Fluent::Log::LEVEL_DEBUG
+  end
+
+  def create_debug_dummy_logger
+    dl_opts = {}
+    dl_opts[:log_level] = ServerEngine::DaemonLogger::DEBUG
+    logdev = Fluent::Test::DummyLogDevice.new
+    logger = ServerEngine::DaemonLogger.new(logdev, dl_opts)
+    $log = Fluent::Log.new(logger)
+  end
+
+  def create_info_dummy_logger
+    dl_opts = {}
+    dl_opts[:log_level] = ServerEngine::DaemonLogger::INFO
+    logdev = Fluent::Test::DummyLogDevice.new
+    logger = ServerEngine::DaemonLogger.new(logdev, dl_opts)
+    $log = Fluent::Log.new(logger)
+  end
+end