fluentd 0.12.40 → 0.14.0

data/test/test_formatter.rb

@@ -29,10 +29,6 @@ module FormatterTest
     {'message' => 'awesome'}
   end
 
-  def symbolic_record
-    {:message => :awesome}
-  end
-
   def with_timezone(tz)
     oldtz, ENV['TZ'] = ENV['TZ'], tz
     yield
@@ -56,7 +52,7 @@ module FormatterTest
     include FormatterTest
 
     def create_driver(conf={})
-      formatter = Fluent::Test::FormatterTestDriver.new(Formatter).configure(conf)
+      Fluent::Test::FormatterTestDriver.new(Formatter).configure(conf)
     end
 
     def test_call
@@ -142,22 +138,6 @@ module FormatterTest
       assert_equal("#{Yajl.dump(record)}\n", formatted)
     end
 
-    data('oj' => 'oj', 'yajl' => 'yajl')
-    def test_format_without_nl(data)
-      @formatter.configure('json_parser' => data, 'add_newline' => false)
-      formatted = @formatter.format(tag, @time, record)
-
-      assert_equal(Yajl.dump(record), formatted)
-    end
-
-    data('oj' => 'oj', 'yajl' => 'yajl')
-    def test_format_with_symbolic_record(data)
-      @formatter.configure('json_parser' => data)
-      formatted = @formatter.format(tag, @time, symbolic_record)
-
-      assert_equal("#{JSON.generate(record)}\n", formatted)
-    end
-
     data('oj' => 'oj', 'yajl' => 'yajl')
     def test_format_with_include_tag(data)
       @formatter.configure('include_tag_key' => 'true', 'tag_key' => 'foo', 'json_parser' => data)
@@ -260,13 +240,6 @@ module FormatterTest
       assert_equal("message:awesome\n", formatted)
     end
 
-    def test_format_without_nl
-      @formatter.configure('add_newline' => false)
-      formatted = @formatter.format(tag, @time, record)
-
-      assert_equal("message:awesome", formatted)
-    end
-
     def test_format_with_tag
       @formatter.configure('include_tag_key' => 'true')
       formatted = @formatter.format(tag, @time, record)
@@ -304,15 +277,7 @@ module FormatterTest
     def test_config_params
       assert_equal ',', @formatter.delimiter
       assert_equal true, @formatter.force_quotes
-      assert_nil @formatter.fields
-    end
-
-    data('empty array' => [],
-         'array including empty string' => ['', ''])
-    def test_empty_fields(param)
-      assert_raise ConfigError do
-        @formatter.configure('fields' => param)
-      end
+      assert_equal [], @formatter.fields
     end
 
     data(
@@ -321,7 +286,7 @@ module FormatterTest
       'pipe' => ['|', '|'])
     def test_config_params_with_customized_delimiters(data)
       expected, target = data
-      @formatter.configure('fields' => 'f1', 'delimiter' => target)
+      @formatter.configure('delimiter' => target)
       assert_equal expected, @formatter.delimiter
     end
 
@@ -334,15 +299,6 @@ module FormatterTest
       assert_equal("\"awesome\",\"awesome2\"\n", formatted)
     end
 
-    def test_format_without_nl
-      @formatter.configure('fields' => 'message,message2', 'add_newline' => false)
-      formatted = @formatter.format(tag, @time, {
-        'message' => 'awesome',
-        'message2' => 'awesome2'
-      })
-      assert_equal("\"awesome\",\"awesome2\"", formatted)
-    end
-
     def test_format_with_tag
       @formatter.configure(
         'fields' => 'tag,message,message2',
@@ -434,13 +390,13 @@ module FormatterTest
     end
 
     def test_format
-      formatter = TextFormatter::TEMPLATE_REGISTRY.lookup('single_value').call
+      formatter = Fluent::Plugin.new_formatter('single_value')
       formatted = formatter.format('tag', Engine.now, {'message' => 'awesome'})
       assert_equal("awesome\n", formatted)
     end
 
     def test_format_without_newline
-      formatter = TextFormatter::TEMPLATE_REGISTRY.lookup('single_value').call
+      formatter = Fluent::Plugin.new_formatter('single_value')
       formatter.configure('add_newline' => 'false')
       formatted = formatter.format('tag', Engine.now, {'message' => 'awesome'})
       assert_equal("awesome", formatted)
@@ -460,7 +416,7 @@ module FormatterTest
 
     def test_unknown_format
       assert_raise ConfigError do
-        TextFormatter::TEMPLATE_REGISTRY.lookup('unknown')
+        Fluent::Plugin.new_formatter('unknown')
       end
     end
 
@@ -468,7 +424,7 @@ module FormatterTest
     def test_find_formatter(data)
       $LOAD_PATH.unshift(File.join(File.expand_path(File.dirname(__FILE__)), 'scripts'))
       assert_nothing_raised ConfigError do
-        TextFormatter::TEMPLATE_REGISTRY.lookup(data)
+        Fluent::Plugin.new_formatter(data)
       end
       $LOAD_PATH.shift
     end
@@ -644,6 +600,12 @@ module FormatterTest
         assert_equal("20140926 1400-1000", format(@fmt, true, "-10"))
       end
     end
+
+    def test_format_with_subsec
+      time = Fluent::EventTime.new(@time)
+      formatter = Fluent::TimeFormatter.new("%Y%m%d %H%M.%N", false, nil)
+      assert_equal("20140927 0000.000000000", formatter.format(time))
+    end
   end
 
   class TimeConfigTest < ::Test::Unit::TestCase

data/test/test_input.rb

@@ -17,7 +17,7 @@ class FluentInputTest < ::Test::Unit::TestCase
     assert_equal Engine.root_agent.event_router, d.instance.router
 
     d = nil
-    assert_nothing_raised { 
+    assert_nothing_raised {
       d = create_driver('@label @known')
     }
     expected = Engine.root_agent.find_label('@known').event_router

data/test/test_log.rb

@@ -11,6 +11,7 @@ class LogTest < Test::Unit::TestCase
   end
 
   def teardown
+    @log_device.reset
     Thread.current[:last_repeated_stacktrace] = nil
   end
 
@@ -25,7 +26,43 @@ class LogTest < Test::Unit::TestCase
     )
     def test_output(data)
       log_level, start = data
-      log = Fluent::Log.new(@log_device, log_level)
+      logdev = @log_device
+      logger = ServerEngine::DaemonLogger.new(logdev)
+      log = Fluent::Log.new(logger)
+      log.level = log_level
+      log.trace "trace log"
+      log.debug "debug log"
+      log.info "info log"
+      log.warn "warn log"
+      log.error "error log"
+      log.fatal "fatal log"
+      expected = [
+        "#{@timestamp_str} [trace]: trace log\n",
+        "#{@timestamp_str} [debug]: debug log\n",
+        "#{@timestamp_str} [info]: info log\n",
+        "#{@timestamp_str} [warn]: warn log\n",
+        "#{@timestamp_str} [error]: error log\n",
+        "#{@timestamp_str} [fatal]: fatal log\n"
+      ][start..-1]
+      assert_equal(expected, log.out.logs)
+    end
+
+    data(
+        trace: [ServerEngine::DaemonLogger::TRACE, 0],
+        debug: [ServerEngine::DaemonLogger::DEBUG, 1],
+        info: [ServerEngine::DaemonLogger::INFO, 2],
+        warn: [ServerEngine::DaemonLogger::WARN, 3],
+        error: [ServerEngine::DaemonLogger::ERROR, 4],
+        fatal: [ServerEngine::DaemonLogger::FATAL, 5],
+    )
+    def test_output_with_serverengine_loglevel(data)
+      log_level, start = data
+
+      dl_opts = {}
+      dl_opts[:log_level] = log_level
+      logdev = @log_device
+      logger = ServerEngine::DaemonLogger.new(logdev, dl_opts)
+      log = Fluent::Log.new(logger)
       log.trace "trace log"
       log.debug "debug log"
       log.info "info log"
@@ -53,7 +90,44 @@ class LogTest < Test::Unit::TestCase
     )
     def test_output_with_block(data)
       log_level, start = data
-      log = Fluent::Log.new(@log_device, log_level)
+
+      logdev = @log_device
+      logger = ServerEngine::DaemonLogger.new(logdev)
+      log = Fluent::Log.new(logger)
+      log.level = log_level
+      log.trace { "trace log" }
+      log.debug { "debug log" }
+      log.info { "info log" }
+      log.warn { "warn log" }
+      log.error { "error log" }
+      log.fatal { "fatal log" }
+      expected = [
+        "#{@timestamp_str} [trace]: trace log\n",
+        "#{@timestamp_str} [debug]: debug log\n",
+        "#{@timestamp_str} [info]: info log\n",
+        "#{@timestamp_str} [warn]: warn log\n",
+        "#{@timestamp_str} [error]: error log\n",
+        "#{@timestamp_str} [fatal]: fatal log\n"
+      ][start..-1]
+      assert_equal(expected, log.out.logs)
+    end
+
+    data(
+        trace: [ServerEngine::DaemonLogger::TRACE, 0],
+        debug: [ServerEngine::DaemonLogger::DEBUG, 1],
+        info: [ServerEngine::DaemonLogger::INFO, 2],
+        warn: [ServerEngine::DaemonLogger::WARN, 3],
+        error: [ServerEngine::DaemonLogger::ERROR, 4],
+        fatal: [ServerEngine::DaemonLogger::FATAL, 5],
+    )
+    def test_output_with_block_with_serverengine_loglevel(data)
+      log_level, start = data
+
+      dl_opts = {}
+      dl_opts[:log_level] = log_level
+      logdev = @log_device
+      logger = ServerEngine::DaemonLogger.new(logdev, dl_opts)
+      log = Fluent::Log.new(logger)
       log.trace { "trace log" }
       log.debug { "debug log" }
       log.info { "info log" }
@@ -81,7 +155,42 @@ class LogTest < Test::Unit::TestCase
     )
     def test_execute_block(data)
       log_level, expected = data
-      log = Fluent::Log.new(@log_device, log_level)
+      logdev = @log_device
+      logger = ServerEngine::DaemonLogger.new(logdev)
+      log = Fluent::Log.new(logger)
+      log.level = log_level
+      block_called = {
+        trace: false,
+        debug: false,
+        info: false,
+        warn: false,
+        error: false,
+        fatal: false,
+      }
+      log.trace { block_called[:trace] = true }
+      log.debug { block_called[:debug] = true }
+      log.info { block_called[:info] = true }
+      log.warn { block_called[:warn] = true }
+      log.error { block_called[:error] = true }
+      log.fatal { block_called[:fatal] = true }
+      assert_equal(expected, block_called)
+    end
+
+    data(
+      trace: [ServerEngine::DaemonLogger::TRACE, { trace: true, debug: true, info: true, warn: true, error: true, fatal: true }],
+      debug: [ServerEngine::DaemonLogger::DEBUG, { trace: false, debug: true, info: true, warn: true, error: true, fatal: true }],
+      info: [ServerEngine::DaemonLogger::INFO, { trace: false, debug: false, info: true, warn: true, error: true, fatal: true }],
+      warn: [ServerEngine::DaemonLogger::WARN, { trace: false, debug: false, info: false, warn: true, error: true, fatal: true }],
+      error: [ServerEngine::DaemonLogger::ERROR, { trace: false, debug: false, info: false, warn: false, error: true, fatal: true }],
+      fatal: [ServerEngine::DaemonLogger::FATAL, { trace: false, debug: false, info: false, warn: false, error: false, fatal: true }],
+    )
+    def test_execute_block_with_serverengine_loglevel(data)
+      log_level, expected = data
+      dl_opts = {}
+      dl_opts[:log_level] = log_level
+      logdev = @log_device
+      logger = ServerEngine::DaemonLogger.new(logdev, dl_opts)
+      log = Fluent::Log.new(logger)
       block_called = {
         trace: false,
         debug: false,
@@ -110,7 +219,55 @@ class LogTest < Test::Unit::TestCase
     def test_backtrace(data)
       log_level, start = data
       backtrace = ["line 1", "line 2", "line 3"]
-      log = Fluent::Log.new(@log_device, log_level)
+      logdev = @log_device
+      logger = ServerEngine::DaemonLogger.new(logdev)
+      log = Fluent::Log.new(logger)
+      log.level = log_level
+      log.trace_backtrace(backtrace)
+      log.debug_backtrace(backtrace)
+      log.info_backtrace(backtrace)
+      log.warn_backtrace(backtrace)
+      log.error_backtrace(backtrace)
+      log.fatal_backtrace(backtrace)
+      expected = [
+        "  #{@timestamp_str} [trace]: line 1\n",
+        "  #{@timestamp_str} [trace]: line 2\n",
+        "  #{@timestamp_str} [trace]: line 3\n",
+        "  #{@timestamp_str} [debug]: line 1\n",
+        "  #{@timestamp_str} [debug]: line 2\n",
+        "  #{@timestamp_str} [debug]: line 3\n",
+        "  #{@timestamp_str} [info]: line 1\n",
+        "  #{@timestamp_str} [info]: line 2\n",
+        "  #{@timestamp_str} [info]: line 3\n",
+        "  #{@timestamp_str} [warn]: line 1\n",
+        "  #{@timestamp_str} [warn]: line 2\n",
+        "  #{@timestamp_str} [warn]: line 3\n",
+        "  #{@timestamp_str} [error]: line 1\n",
+        "  #{@timestamp_str} [error]: line 2\n",
+        "  #{@timestamp_str} [error]: line 3\n",
+        "  #{@timestamp_str} [fatal]: line 1\n",
+        "  #{@timestamp_str} [fatal]: line 2\n",
+        "  #{@timestamp_str} [fatal]: line 3\n"
+      ][start..-1]
+      assert_equal(expected, log.out.logs)
+    end
+
+    data(
+      trace: [ServerEngine::DaemonLogger::TRACE, 0],
+      debug: [ServerEngine::DaemonLogger::DEBUG, 3],
+      info: [ServerEngine::DaemonLogger::INFO, 6],
+      warn: [ServerEngine::DaemonLogger::WARN, 9],
+      error: [ServerEngine::DaemonLogger::ERROR, 12],
+      fatal: [ServerEngine::DaemonLogger::FATAL, 15],
+    )
+    def test_backtrace_with_serverengine_loglevel(data)
+      log_level, start = data
+      backtrace = ["line 1", "line 2", "line 3"]
+      dl_opts = {}
+      dl_opts[:log_level] = log_level
+      logdev = @log_device
+      logger = ServerEngine::DaemonLogger.new(logdev, dl_opts)
+      log = Fluent::Log.new(logger)
       log.trace_backtrace(backtrace)
       log.debug_backtrace(backtrace)
       log.info_backtrace(backtrace)
@@ -144,7 +301,13 @@ class LogTest < Test::Unit::TestCase
   sub_test_case "suppress repeated backtrace" do
     def test_same_log_level
       backtrace = ["line 1", "line 2", "line 3"]
-      log = Fluent::Log.new(@log_device, Fluent::Log::LEVEL_TRACE, suppress_repeated_stacktrace: true)
+      dl_opts = {}
+      dl_opts[:log_level] = ServerEngine::DaemonLogger::TRACE
+      logdev = @log_device
+      logger = ServerEngine::DaemonLogger.new(logdev, dl_opts)
+      opts = {}
+      opts[:suppress_repeated_stacktrace] = true
+      log = Fluent::Log.new(logger, opts)
       log.trace_backtrace(backtrace)
       log.trace_backtrace(backtrace)
       log.trace_backtrace(backtrace + ["line 4"])
@@ -169,7 +332,13 @@ class LogTest < Test::Unit::TestCase
 
     def test_different_log_level
       backtrace = ["line 1", "line 2", "line 3"]
-      log = Fluent::Log.new(@log_device, Fluent::Log::LEVEL_TRACE, suppress_repeated_stacktrace: true)
+      dl_opts = {}
+      dl_opts[:log_level] = ServerEngine::DaemonLogger::TRACE
+      logdev = @log_device
+      logger = ServerEngine::DaemonLogger.new(logdev, dl_opts)
+      opts = {}
+      opts[:suppress_repeated_stacktrace] = true
+      log = Fluent::Log.new(logger, opts)
       log.trace_backtrace(backtrace)
       log.debug_backtrace(backtrace)
       log.info_backtrace(backtrace)
@@ -191,7 +360,11 @@ class LogTest < Test::Unit::TestCase
   end
 
   def test_dup
-    log1 = Fluent::Log.new(@log_device, Fluent::Log::LEVEL_TRACE)
+    dl_opts = {}
+    dl_opts[:log_level] = ServerEngine::DaemonLogger::TRACE
+    logdev = @log_device
+    logger = ServerEngine::DaemonLogger.new(logdev, dl_opts)
+    log1 = Fluent::Log.new(logger)
     log2 = log1.dup
     log1.level = Fluent::Log::LEVEL_DEBUG
     original_tag = log1.tag
@@ -203,13 +376,32 @@ class LogTest < Test::Unit::TestCase
   end
 
   def test_disable_events
-    log = Fluent::Log.new(@log_device, Fluent::Log::LEVEL_TRACE)
+    dl_opts = {}
+    dl_opts[:log_level] = ServerEngine::DaemonLogger::TRACE
+    logdev = @log_device
+    logger = ServerEngine::DaemonLogger.new(logdev, dl_opts)
+    log = Fluent::Log.new(logger)
     engine = log.instance_variable_get("@engine")
     mock(engine).push_log_event(anything, anything, anything).once
     log.trace "trace log"
     log.disable_events(Thread.current)
     log.trace "trace log"
   end
+
+  def test_level_reload
+    dl_opts = {}
+    dl_opts[:log_level] = ServerEngine::DaemonLogger::TRACE
+    logdev = @log_device
+    logger = ServerEngine::DaemonLogger.new(logdev, dl_opts)
+    log = Fluent::Log.new(logger)
+    assert_equal(ServerEngine::DaemonLogger::TRACE, logger.level)
+    assert_equal(Fluent::Log::LEVEL_TRACE, log.level)
+    # change daemon logger side level
+    logger.level = ServerEngine::DaemonLogger::DEBUG
+    assert_equal(ServerEngine::DaemonLogger::DEBUG, logger.level)
+    # check fluentd log side level is also changed
+    assert_equal(Fluent::Log::LEVEL_DEBUG, log.level)
+  end
 end
 
 class PluginLoggerTest < Test::Unit::TestCase
@@ -218,10 +410,15 @@ class PluginLoggerTest < Test::Unit::TestCase
     @timestamp = Time.parse("2016-04-21 11:58:41 +0900")
     @timestamp_str = @timestamp.strftime("%Y-%m-%d %H:%M:%S %z")
     stub(Time).now { @timestamp }
-    @logger = Fluent::Log.new(@log_device, Fluent::Log::LEVEL_TRACE)
+    dl_opts = {}
+    dl_opts[:log_level] = ServerEngine::DaemonLogger::TRACE
+    logdev = @log_device
+    logger = ServerEngine::DaemonLogger.new(logdev, dl_opts)
+    @logger = Fluent::Log.new(logger)
   end
 
   def teardown
+    @log_device.reset
     Thread.current[:last_repeated_stacktrace] = nil
   end
 
@@ -305,22 +502,29 @@ class PluginLoggerTest < Test::Unit::TestCase
       @log.write("log")
     end
 
-    def test_write_alias
-      assert(@log.respond_to?(:<<))
-      mock(@log.out).write("log")
-      @log << "log"
-    end
-
     def test_out
       assert_equal(@log.out, @logger.out)
       @log.out = Object.new
       assert_equal(@log.out, @logger.out)
     end
+
+    def test_optional_header
+      assert_equal(@log.optional_header, @logger.optional_header)
+      @log.optional_header = "optional_header"
+      assert_equal(@log.optional_header, @logger.optional_header)
+    end
+
+    def test_optional_attrs
+      assert_equal(@log.optional_attrs, @logger.optional_attrs)
+      @log.optional_attrs = "optional_attrs"
+      assert_equal(@log.optional_attrs, @logger.optional_attrs)
+    end
   end
 end
 
 class PluginLoggerMixinTest < Test::Unit::TestCase
-  class DummyPlugin < Fluent::Input
+  class DummyPlugin < Fluent::Plugin::TestBase
+    include Fluent::PluginHelper::EventEmitter
   end
 
   def create_driver(conf)
@@ -343,4 +547,23 @@ class PluginLoggerMixinTest < Test::Unit::TestCase
     assert_not_equal($log.level, log.level)
     assert_equal(Fluent::Log::LEVEL_FATAL, log.level)
   end
+
+  def test_optional_header
+    d = create_driver(%[log_level fatal])
+    log = d.instance.log
+    assert_equal("[PluginLoggerMixinTest::DummyPlugin] ", log.optional_header)
+    assert_equal({}, log.optional_attrs)
+  end
+
+  def test_start
+    plugin = DummyPlugin.new
+    mock(plugin.log).reset
+    plugin.start
+  end
+
+  def test_terminate
+    plugin = DummyPlugin.new
+    mock(plugin.log).reset
+    plugin.terminate
+  end
 end