fluentd 0.10.49 → 0.10.50

data/spec/config/section_spec.rb

@@ -60,17 +60,17 @@ describe Fluent::Config::Section do
     describe '#instance_of?' do
       it 'can judge whether it is a Section object or not' do
         s = Fluent::Config::Section.new
-        expect(s.instance_of?(Fluent::Config::Section)).to be_true
-        expect(s.instance_of?(BasicObject)).to be_false
+        expect(s.instance_of?(Fluent::Config::Section)).to be true
+        expect(s.instance_of?(BasicObject)).to be false
       end
     end
 
     describe '#is_a?' do
       it 'can judge whether it belongs to or not' do
         s = Fluent::Config::Section.new
-        expect(s.is_a?(Fluent::Config::Section)).to be_true
-        expect(s.kind_of?(Fluent::Config::Section)).to be_true
-        expect(s.is_a?(BasicObject)).to be_true
+        expect(s.is_a?(Fluent::Config::Section)).to be true
+        expect(s.kind_of?(Fluent::Config::Section)).to be true
+        expect(s.is_a?(BasicObject)).to be true
       end
     end
 

data/test/plugin/test_in_tail.rb

@@ -13,12 +13,17 @@ class TailInputTest < Test::Unit::TestCase
 
   TMP_DIR = File.dirname(__FILE__) + "/../tmp/tail#{ENV['TEST_ENV_NUMBER']}"
 
-  COMMON_CONFIG = %[
+  CONFIG = %[
     path #{TMP_DIR}/tail.txt
     tag t1
     rotate_wait 2s
+  ]
+  COMMON_CONFIG = CONFIG + %[
     pos_file #{TMP_DIR}/tail.pos
   ]
+  CONFIG_READ_FROM_HEAD = %[
+    read_from_head true
+  ]
   SINGLE_LINE_CONFIG = %[
     format /(?<message>.*)/
   ]
@@ -36,6 +41,8 @@ class TailInputTest < Test::Unit::TestCase
     assert_equal "#{TMP_DIR}/tail.pos", d.instance.pos_file
   end
 
+  # TODO: Should using more better approach instead of sleep wait
+
   def test_emit
     File.open("#{TMP_DIR}/tail.txt", "w") {|f|
       f.puts "test1"
@@ -56,8 +63,89 @@ class TailInputTest < Test::Unit::TestCase
 
     emits = d.emits
     assert_equal(true, emits.length > 0)
-    assert_equal({"message"=>"test3"}, emits[0][2])
-    assert_equal({"message"=>"test4"}, emits[1][2])
+    assert_equal({"message" => "test3"}, emits[0][2])
+    assert_equal({"message" => "test4"}, emits[1][2])
+  end
+
+  def test_emit_with_read_from_head
+    File.open("#{TMP_DIR}/tail.txt", "w") {|f|
+      f.puts "test1"
+      f.puts "test2"
+    }
+
+    d = create_driver(CONFIG_READ_FROM_HEAD + SINGLE_LINE_CONFIG)
+
+    d.run do
+      sleep 1
+
+      File.open("#{TMP_DIR}/tail.txt", "a") {|f|
+        f.puts "test3"
+        f.puts "test4"
+      }
+      sleep 1
+    end
+
+    emits = d.emits
+    assert(emits.length > 0)
+    assert_equal({"message" => "test1"}, emits[0][2])
+    assert_equal({"message" => "test2"}, emits[1][2])
+    assert_equal({"message" => "test3"}, emits[2][2])
+    assert_equal({"message" => "test4"}, emits[3][2])
+  end
+
+  def test_rotate_file
+    emits = sub_test_rotate_file(SINGLE_LINE_CONFIG)
+    assert(emits.length > 0)
+    assert_equal({"message" => "test3"}, emits[0][2])
+    assert_equal({"message" => "test4"}, emits[1][2])
+    assert_equal({"message" => "test5"}, emits[2][2])
+    assert_equal({"message" => "test6"}, emits[3][2])
+  end
+
+  def test_rotate_file_with_read_from_head
+    emits = sub_test_rotate_file(CONFIG_READ_FROM_HEAD + SINGLE_LINE_CONFIG)
+    assert(emits.length > 0)
+    assert_equal({"message" => "test1"}, emits[0][2])
+    assert_equal({"message" => "test2"}, emits[1][2])
+    assert_equal({"message" => "test3"}, emits[2][2])
+    assert_equal({"message" => "test4"}, emits[3][2])
+    assert_equal({"message" => "test5"}, emits[4][2])
+    assert_equal({"message" => "test6"}, emits[5][2])
+  end
+
+  def sub_test_rotate_file(config = nil)
+    File.open("#{TMP_DIR}/tail.txt", "w") {|f|
+      f.puts "test1"
+      f.puts "test2"
+    }
+    d = create_driver(config)
+    d.run do
+      sleep 1
+
+      File.open("#{TMP_DIR}/tail.txt", "a") {|f|
+        f.puts "test3"
+        f.puts "test4"
+      }
+      sleep 1
+
+      FileUtils.mv("#{TMP_DIR}/tail.txt", "#{TMP_DIR}/tail2.txt")
+      sleep 1
+
+      File.open("#{TMP_DIR}/tail.txt", "w") {|f| }
+      sleep 1
+
+      File.open("#{TMP_DIR}/tail.txt", "a") {|f|
+        f.puts "test5"
+        f.puts "test6"
+      }
+      sleep 1
+    end
+
+    d.run do
+      sleep 1
+    end
+
+    d.emits
   end
 
   def test_lf
@@ -79,7 +167,7 @@ class TailInputTest < Test::Unit::TestCase
 
     emits = d.emits
     assert_equal(true, emits.length > 0)
-    assert_equal({"message"=>"test3test4"}, emits[0][2])
+    assert_equal({"message" => "test3test4"}, emits[0][2])
   end
 
   def test_whitespace
@@ -103,12 +191,12 @@ class TailInputTest < Test::Unit::TestCase
 
     emits = d.emits
     assert_equal(true, emits.length > 0)
-    assert_equal({"message"=>"    "}, emits[0][2])
-    assert_equal({"message"=>"    4 spaces"}, emits[1][2])
-    assert_equal({"message"=>"4 spaces    "}, emits[2][2])
-    assert_equal({"message"=>"	"}, emits[3][2])
-    assert_equal({"message"=>"	tab"}, emits[4][2])
-    assert_equal({"message"=>"tab	"}, emits[5][2])
+    assert_equal({"message" => "    "}, emits[0][2])
+    assert_equal({"message" => "    4 spaces"}, emits[1][2])
+    assert_equal({"message" => "4 spaces    "}, emits[2][2])
+    assert_equal({"message" => "	"}, emits[3][2])
+    assert_equal({"message" => "	tab"}, emits[4][2])
+    assert_equal({"message" => "tab	"}, emits[5][2])
   end
 
   # multiline mode test
@@ -207,6 +295,33 @@ class TailInputTest < Test::Unit::TestCase
     assert_equal({"message" => "test4"}, emits[3][2])
   end
 
+  def test_multiline_without_firstline
+    File.open("#{TMP_DIR}/tail.txt", "w") { |f| }
+
+    d = create_driver %[
+      format multiline
+      format1 /(?<var1>foo \\d)\\n/
+      format2 /(?<var2>bar \\d)\\n/
+      format3 /(?<var3>baz \\d)/
+    ]
+    d.run do
+      File.open("#{TMP_DIR}/tail.txt", "a") { |f|
+        f.puts "foo 1"
+        f.puts "bar 1"
+        f.puts "baz 1"
+        f.puts "foo 2"
+        f.puts "bar 2"
+        f.puts "baz 2"
+      }
+      sleep 1
+    end
+
+    emits = d.emits
+    assert_equal(2, emits.length)
+    assert_equal({"var1" => "foo 1", "var2" => "bar 1", "var3" => "baz 1"}, emits[0][2])
+    assert_equal({"var1" => "foo 2", "var2" => "bar 2", "var3" => "baz 2"}, emits[1][2])
+  end
+
   # * path test
   # TODO: Clean up tests
   EX_RORATE_WAIT = 0
@@ -247,7 +362,7 @@ class TailInputTest < Test::Unit::TestCase
 
       flexstub(Fluent::NewTailInput::TailWatcher) do |watcherclass|
         EX_PATHS.each do |path|
-          watcherclass.should_receive(:new).with(path, EX_RORATE_WAIT, Fluent::NewTailInput::FilePositionEntry, any, any, any).once.and_return do
+          watcherclass.should_receive(:new).with(path, EX_RORATE_WAIT, Fluent::NewTailInput::FilePositionEntry, any, true, any, any).once.and_return do
             flexmock('TailWatcher') { |watcher|
               watcher.should_receive(:attach).once
               watcher.should_receive(:unwatched=).zero_or_more_times
@@ -263,7 +378,7 @@ class TailInputTest < Test::Unit::TestCase
       end
 
       flexstub(Fluent::NewTailInput::TailWatcher) do |watcherclass|
-        watcherclass.should_receive(:new).with('test/plugin/data/2010/01/20100102-030406.log', EX_RORATE_WAIT, Fluent::NewTailInput::FilePositionEntry, any, any, any).once.and_return do
+        watcherclass.should_receive(:new).with('test/plugin/data/2010/01/20100102-030406.log', EX_RORATE_WAIT, Fluent::NewTailInput::FilePositionEntry, any, true, any, any).once.and_return do
           flexmock('TailWatcher') do |watcher|
             watcher.should_receive(:attach).once
             watcher.should_receive(:unwatched=).zero_or_more_times
@@ -368,8 +483,8 @@ class TailInputTest < Test::Unit::TestCase
       end
       emits = d.emits
       assert_equal(2, emits.length)
-      assert_equal({"message"=>"test3"}, emits[0][2])
-      assert_equal({"message"=>"test4"}, emits[1][2])
+      assert_equal({"message" => "test3"}, emits[0][2])
+      assert_equal({"message" => "test4"}, emits[1][2])
     end
   end
 end

data/test/plugin/test_out_file.rb

@@ -89,6 +89,30 @@ class FileOutputTest < Test::Unit::TestCase
     check_gzipped_result(path, %[#{Yajl.dump({"a" => 1, 'time' => time})}\n] + %[#{Yajl.dump({"a" => 2, 'time' => time})}\n])
   end
 
+  def test_write_with_format_ltsv
+    d = create_driver [CONFIG, 'format ltsv', 'include_time_key true'].join("\n")
+
+    time = Time.parse("2011-01-02 13:14:15 UTC").to_i
+    d.emit({"a"=>1}, time)
+    d.emit({"a"=>2}, time)
+
+    # FileOutput#write returns path
+    path = d.run
+    check_gzipped_result(path, %[a:1\ttime:2011-01-02T13:14:15Z\n] + %[a:2\ttime:2011-01-02T13:14:15Z\n])
+  end
+
+  def test_write_with_format_single_value
+    d = create_driver [CONFIG, 'format single_value', 'message_key a'].join("\n")
+
+    time = Time.parse("2011-01-02 13:14:15 UTC").to_i
+    d.emit({"a"=>1}, time)
+    d.emit({"a"=>2}, time)
+
+    # FileOutput#write returns path
+    path = d.run
+    check_gzipped_result(path, %[1\n] + %[2\n])
+  end
+
   def test_write_path_increment
     d = create_driver
 

data/test/test_formatter.rb

@@ -177,7 +177,14 @@ module FormatterTest
     def test_format
       formatter = TextFormatter::TEMPLATE_REGISTRY.lookup('single_value').call
       formatted = formatter.format('tag', Engine.now, {'message' => 'awesome'})
-      assert_equal('awesome', formatted)
+      assert_equal("awesome\n", formatted)
+    end
+
+    def test_format_without_newline
+      formatter = TextFormatter::TEMPLATE_REGISTRY.lookup('single_value').call
+      formatter.configure('add_newline' => 'false')
+      formatted = formatter.format('tag', Engine.now, {'message' => 'awesome'})
+      assert_equal("awesome", formatted)
     end
 
     def test_format_with_message_key
@@ -185,7 +192,7 @@ module FormatterTest
       formatter.configure('message_key' => 'foobar')
       formatted = formatter.format('tag', Engine.now, {'foobar' => 'foo'})
 
-      assert_equal('foo', formatted)
+      assert_equal("foo\n", formatted)
     end
   end
 

data/test/test_parser.rb

@@ -45,18 +45,19 @@ module ParserTest
     include ParserTest
 
     def internal_test_case(parser)
-      time, record = parser.call('192.168.0.1 - - [28/Feb/2013:12:00:00 +0900] [14/Feb/2013:12:00:00 +0900] "true /,/user HTTP/1.1" 200 777')
-
-      assert_equal(str2time('28/Feb/2013:12:00:00 +0900', '%d/%b/%Y:%H:%M:%S %z'), time)
-      assert_equal({
-        'user' => '-',
-        'flag' => true,
-        'code' => 200.0,
-        'size' => 777,
-        'date' => str2time('14/Feb/2013:12:00:00 +0900', '%d/%b/%Y:%H:%M:%S %z'),
-        'host' => '192.168.0.1',
-        'path' => ['/', '/user']
-      }, record)
+      text = '192.168.0.1 - - [28/Feb/2013:12:00:00 +0900] [14/Feb/2013:12:00:00 +0900] "true /,/user HTTP/1.1" 200 777'
+      [parser.call(text), parser.call(text) { |time, record| return time, record}].each { |time, record|
+        assert_equal(str2time('28/Feb/2013:12:00:00 +0900', '%d/%b/%Y:%H:%M:%S %z'), time)
+        assert_equal({
+          'user' => '-',
+          'flag' => true,
+          'code' => 200.0,
+          'size' => 777,
+          'date' => str2time('14/Feb/2013:12:00:00 +0900', '%d/%b/%Y:%H:%M:%S %z'),
+          'host' => '192.168.0.1',
+          'path' => ['/', '/user']
+        }, record)
+      }
     end
 
     def test_call_with_typed
@@ -84,17 +85,17 @@ module ParserTest
     end
 
     def test_call
-      time, record = @parser.call('192.168.0.1 - - [28/Feb/2013:12:00:00 +0900] "GET / HTTP/1.1" 200 777')
-
-      assert_equal(str2time('28/Feb/2013:12:00:00 +0900', '%d/%b/%Y:%H:%M:%S %z'), time)
-      assert_equal({
-        'user'    => '-',
-        'method'  => 'GET',
-        'code'    => '200',
-        'size'    => '777',
-        'host'    => '192.168.0.1',
-        'path'    => '/'
-      }, record)
+      @parser.call('192.168.0.1 - - [28/Feb/2013:12:00:00 +0900] "GET / HTTP/1.1" 200 777') { |time, record|
+        assert_equal(str2time('28/Feb/2013:12:00:00 +0900', '%d/%b/%Y:%H:%M:%S %z'), time)
+        assert_equal({
+          'user'    => '-',
+          'method'  => 'GET',
+          'code'    => '200',
+          'size'    => '777',
+          'host'    => '192.168.0.1',
+          'path'    => '/'
+        }, record)
+      }
     end
   end
 
@@ -106,19 +107,19 @@ module ParserTest
     end
 
     def test_call
-      time, record = @parser.call('192.168.0.1 - - [28/Feb/2013:12:00:00 +0900] "GET / HTTP/1.1" 200 777 "-" "Opera/12.0"')
-
-      assert_equal(str2time('28/Feb/2013:12:00:00 +0900', '%d/%b/%Y:%H:%M:%S %z'), time)
-      assert_equal({
-        'user'    => nil,
-        'method'  => 'GET',
-        'code'    => 200,
-        'size'    => 777,
-        'host'    => '192.168.0.1',
-        'path'    => '/',
-        'referer' => nil,
-        'agent'   => 'Opera/12.0'
-      }, record)
+      @parser.call('192.168.0.1 - - [28/Feb/2013:12:00:00 +0900] "GET / HTTP/1.1" 200 777 "-" "Opera/12.0"') { |time, record|
+        assert_equal(str2time('28/Feb/2013:12:00:00 +0900', '%d/%b/%Y:%H:%M:%S %z'), time)
+        assert_equal({
+          'user'    => nil,
+          'method'  => 'GET',
+          'code'    => 200,
+          'size'    => 777,
+          'host'    => '192.168.0.1',
+          'path'    => '/',
+          'referer' => nil,
+          'agent'   => 'Opera/12.0'
+        }, record)
+      }
     end
   end
 
@@ -130,15 +131,15 @@ module ParserTest
     end
 
     def test_call
-      time, record = @parser.call('Feb 28 12:00:00 192.168.0.1 fluentd[11111]: [error] Syslog test')
-
-      assert_equal(str2time('Feb 28 12:00:00', '%b %d %H:%M:%S'), time)
-      assert_equal({
-        'host'    => '192.168.0.1',
-        'ident'   => 'fluentd',
-        'pid'     => '11111',
-        'message' => '[error] Syslog test'
-      }, record)
+      @parser.call('Feb 28 12:00:00 192.168.0.1 fluentd[11111]: [error] Syslog test') { |time, record|
+        assert_equal(str2time('Feb 28 12:00:00', '%b %d %H:%M:%S'), time)
+        assert_equal({
+          'host'    => '192.168.0.1',
+          'ident'   => 'fluentd',
+          'pid'     => '11111',
+          'message' => '[error] Syslog test'
+        }, record)
+      }
     end
   end
 
@@ -150,14 +151,14 @@ module ParserTest
     end
 
     def test_call
-      time, record = @parser.call('{"time":1362020400,"host":"192.168.0.1","size":777,"method":"PUT"}')
-
-      assert_equal(str2time('2013-02-28 12:00:00 +0900').to_i, time)
-      assert_equal({
-        'host'   => '192.168.0.1',
-        'size'   => 777,
-        'method' => 'PUT',
-      }, record)
+      @parser.call('{"time":1362020400,"host":"192.168.0.1","size":777,"method":"PUT"}') { |time, record|
+        assert_equal(str2time('2013-02-28 12:00:00 +0900').to_i, time)
+        assert_equal({
+          'host'   => '192.168.0.1',
+          'size'   => 777,
+          'method' => 'PUT',
+        }, record)
+      }
     end
   end
 
@@ -180,17 +181,62 @@ module ParserTest
     end
 
     def test_call
-      time, record = @parser.call('127.0.0.1 192.168.0.1 - [28/Feb/2013:12:00:00 +0900] "GET / HTTP/1.1" 200 777 "-" "Opera/12.0"')
-
-      assert_equal(str2time('28/Feb/2013:12:00:00 +0900', '%d/%b/%Y:%H:%M:%S %z'), time)
-      assert_equal(@expected, record)
+      @parser.call('127.0.0.1 192.168.0.1 - [28/Feb/2013:12:00:00 +0900] "GET / HTTP/1.1" 200 777 "-" "Opera/12.0"') { |time, record|
+        assert_equal(str2time('28/Feb/2013:12:00:00 +0900', '%d/%b/%Y:%H:%M:%S %z'), time)
+        assert_equal(@expected, record)
+      }
     end
 
     def test_call_with_empty_included_path
-      time, record = @parser.call('127.0.0.1 192.168.0.1 - [28/Feb/2013:12:00:00 +0900] "GET /a[ ]b HTTP/1.1" 200 777 "-" "Opera/12.0"')
+      @parser.call('127.0.0.1 192.168.0.1 - [28/Feb/2013:12:00:00 +0900] "GET /a[ ]b HTTP/1.1" 200 777 "-" "Opera/12.0"') { |time, record|
+        assert_equal(str2time('28/Feb/2013:12:00:00 +0900', '%d/%b/%Y:%H:%M:%S %z'), time)
+        assert_equal(@expected.merge('path' => '/a[ ]b'), record)
+      }
+    end
+  end
+
+  class TSVParserTest < ::Test::Unit::TestCase
+    include ParserTest
+
+    def test_config_params
+      parser = TextParser::TSVParser.new
 
-      assert_equal(str2time('28/Feb/2013:12:00:00 +0900', '%d/%b/%Y:%H:%M:%S %z'), time)
-      assert_equal(@expected.merge('path' => '/a[ ]b'), record)
+      assert_equal "\t", parser.delimiter
+
+      parser.configure(
+        'keys' => 'a,b',
+        'delimiter' => ',',
+      )
+
+      assert_equal ",", parser.delimiter
+    end
+
+    def test_call
+      parser = TextParser::TSVParser.new
+      parser.configure('keys' => 'time,a,b', 'time_key' => 'time')
+      parser.call("2013/02/28 12:00:00\t192.168.0.1\t111") { |time, record|
+        assert_equal(str2time('2013/02/28 12:00:00', '%Y/%m/%d %H:%M:%S'), time)
+        assert_equal({
+          'a' => '192.168.0.1',
+          'b' => '111',
+        }, record)
+      }
+    end
+  end
+
+  class CSVParserTest < ::Test::Unit::TestCase
+    include ParserTest
+
+    def test_call
+      parser = TextParser::CSVParser.new
+      parser.configure('keys' => 'time,c,d', 'time_key' => 'time')
+      parser.call("2013/02/28 12:00:00,192.168.0.1,111") { |time, record|
+        assert_equal(str2time('2013/02/28 12:00:00', '%Y/%m/%d %H:%M:%S'), time)
+        assert_equal({
+          'c' => '192.168.0.1',
+          'd' => '111',
+        }, record)
+      }
     end
   end
 
@@ -215,13 +261,13 @@ module ParserTest
     def test_call
       parser = TextParser::LabeledTSVParser.new
       parser.configure({})
-      time, record = parser.call("time:2013/02/28 12:00:00\thost:192.168.0.1\treq_id:111")
-
-      assert_equal(str2time('2013/02/28 12:00:00', '%Y/%m/%d %H:%M:%S'), time)
-      assert_equal({
-        'host'   => '192.168.0.1',
-        'req_id' => '111',
-      }, record)
+      parser.call("time:2013/02/28 12:00:00\thost:192.168.0.1\treq_id:111") { |time, record|
+        assert_equal(str2time('2013/02/28 12:00:00', '%Y/%m/%d %H:%M:%S'), time)
+        assert_equal({
+          'host'   => '192.168.0.1',
+          'req_id' => '111',
+        }, record)
+      }
     end
 
     def test_call_with_customized_delimiter
@@ -230,13 +276,13 @@ module ParserTest
         'delimiter'       => ',',
         'label_delimiter' => '=',
       )
-      time, record = parser.call('time=2013/02/28 12:00:00,host=192.168.0.1,req_id=111')
-
-      assert_equal(str2time('2013/02/28 12:00:00', '%Y/%m/%d %H:%M:%S'), time)
-      assert_equal({
-        'host'   => '192.168.0.1',
-        'req_id' => '111',
-      }, record)
+      parser.call('time=2013/02/28 12:00:00,host=192.168.0.1,req_id=111') { |time, record|
+        assert_equal(str2time('2013/02/28 12:00:00', '%Y/%m/%d %H:%M:%S'), time)
+        assert_equal({
+          'host'   => '192.168.0.1',
+          'req_id' => '111',
+        }, record)
+      }
     end
 
     def test_call_with_customized_time_format
@@ -245,13 +291,13 @@ module ParserTest
         'time_key'    => 'mytime',
         'time_format' => '%d/%b/%Y:%H:%M:%S %z',
       )
-      time, record = parser.call("mytime:28/Feb/2013:12:00:00 +0900\thost:192.168.0.1\treq_id:111")
-
-      assert_equal(str2time('28/Feb/2013:12:00:00 +0900', '%d/%b/%Y:%H:%M:%S %z'), time)
-      assert_equal({
-        'host'   => '192.168.0.1',
-        'req_id' => '111',
-      }, record)
+      parser.call("mytime:28/Feb/2013:12:00:00 +0900\thost:192.168.0.1\treq_id:111") { |time, record|
+        assert_equal(str2time('28/Feb/2013:12:00:00 +0900', '%d/%b/%Y:%H:%M:%S %z'), time)
+        assert_equal({
+          'host'   => '192.168.0.1',
+          'req_id' => '111',
+        }, record)
+      }
     end
   end
 
@@ -268,17 +314,17 @@ module ParserTest
 
     def test_call
       parser = TextParser::TEMPLATE_REGISTRY.lookup('none').call
-      time, record = parser.call('log message!')
-
-      assert_equal({'message' => 'log message!'}, record)
+      parser.call('log message!') { |time, record|
+        assert_equal({'message' => 'log message!'}, record)
+      }
     end
 
     def test_call_with_message_key
       parser = TextParser::NoneParser.new
       parser.configure('message_key' => 'foobar')
-      time, record = parser.call('log message!')
-
-      assert_equal({'foobar' => 'log message!'}, record)
+      parser.call('log message!') { |time, record|
+        assert_equal({'foobar' => 'log message!'}, record)
+      }
     end
   end
 
@@ -301,31 +347,33 @@ module ParserTest
 
     def test_call
       parser = create_parser('format1' => '/^(?<time>\d{4}-\d{1,2}-\d{1,2} \d{1,2}:\d{1,2}:\d{1,2}) \[(?<thread>.*)\] (?<level>[^\s]+)(?<message>.*)/')
-      time, record = parser.call(<<EOS.chomp)
+      parser.call(<<EOS.chomp) { |time, record|
 2013-3-03 14:27:33 [main] ERROR Main - Exception
 javax.management.RuntimeErrorException: null
 \tat Main.main(Main.java:16) ~[bin/:na]
 EOS
 
-      assert_equal(str2time('2013-3-03 14:27:33').to_i, time)
-      assert_equal({
-        "thread"  => "main",
-        "level"   => "ERROR",
-        "message" => " Main - Exception\njavax.management.RuntimeErrorException: null\n\tat Main.main(Main.java:16) ~[bin/:na]"
-      }, record)
+        assert_equal(str2time('2013-3-03 14:27:33').to_i, time)
+        assert_equal({
+          "thread"  => "main",
+          "level"   => "ERROR",
+          "message" => " Main - Exception\njavax.management.RuntimeErrorException: null\n\tat Main.main(Main.java:16) ~[bin/:na]"
+        }, record)
+      }
     end
 
     def test_call_with_firstline
       parser = create_parser('format_firstline' => '/----/', 'format1' => '/time=(?<time>\d{4}-\d{1,2}-\d{1,2} \d{1,2}:\d{1,2}:\d{1,2}).*message=(?<message>.*)/')
-      time, record = parser.call(<<EOS.chomp)
+      parser.call(<<EOS.chomp) { |time, record|
 ----
 time=2013-3-03 14:27:33 
 message=test1
 EOS
 
-      assert(parser.firstline?('----'))
-      assert_equal(str2time('2013-3-03 14:27:33').to_i, time)
-      assert_equal({"message" => "test1"}, record)
+        assert(parser.firstline?('----'))
+        assert_equal(str2time('2013-3-03 14:27:33').to_i, time)
+        assert_equal({"message" => "test1"}, record)
+      }
     end
 
     def test_call_with_multiple_formats
@@ -336,7 +384,7 @@ EOS
         'format4' => '/  Rendered (?<template>[^ ]+) within (?<layout>.+) \([\d\.]+ms\)\n/',
         'format5' => '/Completed (?<code>[^ ]+) [^ ]+ in (?<runtime>[\d\.]+)ms \(Views: (?<view_runtime>[\d\.]+)ms \| ActiveRecord: (?<ar_runtime>[\d\.]+)ms\)/'
         )
-      time, record = parser.call(<<EOS.chomp)
+      parser.call(<<EOS.chomp) { |time, record|
 Started GET "/users/123/" for 127.0.0.1 at 2013-06-14 12:00:11 +0900
 Processing by UsersController#show as HTML
   Parameters: {"user_id"=>"123"}
@@ -344,40 +392,82 @@ Processing by UsersController#show as HTML
 Completed 200 OK in 4ms (Views: 3.2ms | ActiveRecord: 0.0ms)
 EOS
 
-      assert(parser.firstline?('Started GET "/users/123/" for 127.0.0.1...'))
-      assert_equal(str2time('2013-06-14 12:00:11 +0900').to_i, time)
-      assert_equal({
-        "method" => "GET",
-        "path" => "/users/123/",
-        "host" => "127.0.0.1",
-        "controller" => "UsersController",
-        "controller_method" => "show",
-        "format" => "HTML",
-        "parameters" => "{\"user_id\"=>\"123\"}",
-        "template" => "users/show.html.erb",
-        "layout" => "layouts/application",
-        "code" => "200",
-        "runtime" => "4",
-        "view_runtime" => "3.2",
-        "ar_runtime" => "0.0"
-      }, record)
+        assert(parser.firstline?('Started GET "/users/123/" for 127.0.0.1...'))
+        assert_equal(str2time('2013-06-14 12:00:11 +0900').to_i, time)
+        assert_equal({
+          "method" => "GET",
+          "path" => "/users/123/",
+          "host" => "127.0.0.1",
+          "controller" => "UsersController",
+          "controller_method" => "show",
+          "format" => "HTML",
+          "parameters" => "{\"user_id\"=>\"123\"}",
+          "template" => "users/show.html.erb",
+          "layout" => "layouts/application",
+          "code" => "200",
+          "runtime" => "4",
+          "view_runtime" => "3.2",
+          "ar_runtime" => "0.0"
+        }, record)
+      }
     end
   end
 
-  class ParserLookupTest < ::Test::Unit::TestCase
+  class TextParserTest < ::Test::Unit::TestCase
     include ParserTest
 
-    def test_unknown_format
+    class MultiEventTestParser
+      include Fluent::Configurable
+
+      def call(text)
+        2.times { |i|
+          record = {}
+          record['message'] = text
+          record['number'] = i
+          yield Fluent::Engine.now, record
+        }
+      end
+    end
+
+    TextParser.register_template('multi_event_test', Proc.new { MultiEventTestParser.new })
+
+    def test_lookup_unknown_format
       assert_raise ConfigError do
         TextParser::TEMPLATE_REGISTRY.lookup('unknown')
       end
     end
 
-    def test_find_parser
+    def test_lookup_known_parser
       $LOAD_PATH.unshift(File.join(File.expand_path(File.dirname(__FILE__)), 'scripts'))
       assert_nothing_raised ConfigError do
         TextParser::TEMPLATE_REGISTRY.lookup('known')
       end
     end
+
+    def test_parse_with_return
+      parser = TextParser.new
+      parser.configure('format' => 'none')
+      time, record = parser.parse('log message!')
+      assert_equal({'message' => 'log message!'}, record)
+    end
+
+    def test_parse_with_block
+      parser = TextParser.new
+      parser.configure('format' => 'none')
+      parser.parse('log message!') { |time, record|
+        assert_equal({'message' => 'log message!'}, record)
+      }
+    end
+
+    def test_multi_event_parser
+      parser = TextParser.new
+      parser.configure('format' => 'multi_event_test')
+      i = 0
+      parser.parse('log message!') { |time, record|
+        assert_equal('log message!', record['message'])
+        assert_equal(i, record['number'])
+        i += 1
+      }
+    end
   end
 end