fluentd 0.12.0.pre.3 → 0.12.0

data/test/test_formatter.rb

@@ -36,6 +36,18 @@ module FormatterTest
     ENV['TZ'] = oldtz
   end
 
+  class BaseFormatterTest < ::Test::Unit::TestCase
+    include FormatterTest
+
+    def test_call
+      formatter = Formatter.new
+      formatter.configure({})
+      assert_raise NotImplementedError do
+        formatter.format('tag', Engine.now, {})
+      end
+    end
+  end
+
   class OutFileFormatterTest < ::Test::Unit::TestCase
     include FormatterTest
 

data/test/test_output.rb

@@ -62,6 +62,22 @@ module FluentOutputTest
       assert_equal 4, d.instance.calc_retry_wait
     end
 
+    def test_large_num_retries
+      # Test that everything works properly after a very large number of
+      # retries and we hit the expected max_retry_wait.
+      exp_max_retry_wait = 300
+      d = create_driver(CONFIG + %[
+        disable_retry_limit true
+        max_retry_wait #{exp_max_retry_wait}
+      ])
+      d.instance.instance_eval { @num_errors += 1000 }
+      assert_equal exp_max_retry_wait, d.instance.calc_retry_wait
+      d.instance.instance_eval { @num_errors += 1000 }
+      assert_equal exp_max_retry_wait, d.instance.calc_retry_wait
+      d.instance.instance_eval { @num_errors += 1000 }
+      assert_equal exp_max_retry_wait, d.instance.calc_retry_wait
+    end
+
     def create_mock_driver(conf=CONFIG)
       Fluent::Test::BufferedOutputTestDriver.new(Fluent::BufferedOutput) do
         attr_accessor :submit_flush_threads

data/test/test_parser.rb

@@ -13,6 +13,32 @@ module ParserTest
     end
   end
 
+  class BaseParserTest < ::Test::Unit::TestCase
+    include ParserTest
+
+    def create_parser
+      parser = Parser.new
+      parser.configure({})
+      parser
+    end
+
+    def test_init
+      assert_true create_parser.estimate_current_event
+    end
+
+    def test_parse
+      assert_raise NotImplementedError do
+        create_parser.parse('')
+      end
+    end
+
+    def test_call
+      assert_raise NotImplementedError do
+        create_parser.call('')
+      end
+    end
+  end
+
   class TimeParserTest < ::Test::Unit::TestCase
     include ParserTest
 
@@ -23,18 +49,18 @@ module ParserTest
       assert_equal(time, parser.parse('2013-09-18 12:00:00 +0900'))
     end
 
-    def test_call_with_strptime
+    def test_parse_with_strptime
       parser = TextParser::TimeParser.new('%d/%b/%Y:%H:%M:%S %z')
 
       time = str2time('28/Feb/2013:12:00:00 +0900', '%d/%b/%Y:%H:%M:%S %z')
       assert_equal(time, parser.parse('28/Feb/2013:12:00:00 +0900'))
     end
 
-    def test_call_with_invalid_argument
+    def test_parse_with_invalid_argument
       parser = TextParser::TimeParser.new(nil)
 
       [[], {}, nil, true, 10000].each { |v|
-        assert_raise Fluent::TextParser::ParserError do
+        assert_raise Fluent::ParserError do
           parser.parse(v)
         end
       }
@@ -46,7 +72,7 @@ module ParserTest
 
     def internal_test_case(parser)
       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|
+      [parser.parse(text), parser.parse(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' => '-',
@@ -60,12 +86,12 @@ module ParserTest
       }
     end
 
-    def test_call_with_typed
+    def test_parse_with_typed
       # Use Regexp.new instead of // literal to avoid different parser behaviour in 1.9 and 2.0 
       internal_test_case(TextParser::RegexpParser.new(Regexp.new(%q!^(?<host>[^ ]*) [^ ]* (?<user>[^ ]*) \[(?<time>[^\]]*)\] \[(?<date>[^\]]*)\] "(?<flag>\S+)(?: +(?<path>[^ ]*) +\S*)?" (?<code>[^ ]*) (?<size>[^ ]*)$!), 'time_format'=>"%d/%b/%Y:%H:%M:%S %z", 'types'=>'user:string,date:time:%d/%b/%Y:%H:%M:%S %z,flag:bool,path:array,code:float,size:integer'))
     end
 
-    def test_call_with_configure
+    def test_parse_with_configure
       # Specify conf by configure method instaed of intializer
       regexp = Regexp.new(%q!^(?<host>[^ ]*) [^ ]* (?<user>[^ ]*) \[(?<time>[^\]]*)\] \[(?<date>[^\]]*)\] "(?<flag>\S+)(?: +(?<path>[^ ]*) +\S*)?" (?<code>[^ ]*) (?<size>[^ ]*)$!)
       parser = TextParser::RegexpParser.new(regexp)
@@ -75,18 +101,18 @@ module ParserTest
       assert_equal("%d/%b/%Y:%H:%M:%S %z", parser.patterns['time_format'])
     end
 
-    def test_call_with_typed_and_name_separator
+    def test_parse_with_typed_and_name_separator
       internal_test_case(TextParser::RegexpParser.new(Regexp.new(%q!^(?<host>[^ ]*) [^ ]* (?<user>[^ ]*) \[(?<time>[^\]]*)\] \[(?<date>[^\]]*)\] "(?<flag>\S+)(?: +(?<path>[^ ]*) +\S*)?" (?<code>[^ ]*) (?<size>[^ ]*)$!), 'time_format'=>"%d/%b/%Y:%H:%M:%S %z", 'types'=>'user|string,date|time|%d/%b/%Y:%H:%M:%S %z,flag|bool,path|array,code|float,size|integer', 'types_label_delimiter'=>'|'))
     end
 
-    def test_call_without_time
+    def test_parse_without_time
       time_at_start = Time.now.to_i
       text = "tagomori_satoshi tagomoris 34\n"
 
       parser = TextParser::RegexpParser.new(Regexp.new(%q!^(?<name>[^ ]*) (?<user>[^ ]*) (?<age>\d*)$!))
       parser.configure('types'=>'name:string,user:string,age:bool')
 
-      [parser.call(text), parser.call(text) { |time, record| return time, record}].each { |time, record|
+      [parser.parse(text), parser.parse(text) { |time, record| return time, record}].each { |time, record|
         assert time && time >= time_at_start, "parser puts current time without time input"
         assert_equal "tagomori_satoshi", record["name"]
         assert_equal "tagomoris", record["user"]
@@ -97,14 +123,13 @@ module ParserTest
       parser2.configure('types'=>'name:string,user:string,age:bool')
       parser2.time_default_current = false
 
-      [parser2.call(text), parser2.call(text) { |time, record| return time, record}].each { |time, record|
+      [parser2.parse(text), parser2.parse(text) { |time, record| return time, record}].each { |time, record|
         assert_equal "tagomori_satoshi", record["name"]
         assert_equal "tagomoris", record["user"]
         assert_equal 34, record["age"]
 
         assert_nil time, "parser returns nil if configured so"
       }
-
     end
   end
 
@@ -115,8 +140,10 @@ module ParserTest
       @parser = TextParser::TEMPLATE_REGISTRY.lookup('apache').call
     end
 
-    def test_call
-      @parser.call('192.168.0.1 - - [28/Feb/2013:12:00:00 +0900] "GET / HTTP/1.1" 200 777') { |time, record|
+    data('parse' => :parse, 'call' => :call)
+    def test_call(method_name)
+      m = @parser.method(method_name)
+      m.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'    => '-',
@@ -142,22 +169,22 @@ module ParserTest
       }
     end
 
-    def test_call
-      @parser.call('[Wed Oct 11 14:32:52 2000] [error] [client 127.0.0.1] client denied by server configuration') { |time, record|
+    def test_parse
+      @parser.parse('[Wed Oct 11 14:32:52 2000] [error] [client 127.0.0.1] client denied by server configuration') { |time, record|
         assert_equal(str2time('Wed Oct 11 14:32:52 2000'), time)
         assert_equal(@expected, record)
       }
     end
 
-    def test_call_with_pid
-      @parser.call('[Wed Oct 11 14:32:52 2000] [error] [pid 1000] [client 127.0.0.1] client denied by server configuration') { |time, record|
+    def test_parse_with_pid
+      @parser.parse('[Wed Oct 11 14:32:52 2000] [error] [pid 1000] [client 127.0.0.1] client denied by server configuration') { |time, record|
         assert_equal(str2time('Wed Oct 11 14:32:52 2000'), time)
         assert_equal(@expected.merge('pid' => '1000'), record)
       }
     end
 
-    def test_call_without_client
-      @parser.call('[Wed Oct 11 14:32:52 2000] [notice] Apache/2.2.15 (Unix) DAV/2 configured -- resuming normal operations') { |time, record|
+    def test_parse_without_client
+      @parser.parse('[Wed Oct 11 14:32:52 2000] [notice] Apache/2.2.15 (Unix) DAV/2 configured -- resuming normal operations') { |time, record|
         assert_equal(str2time('Wed Oct 11 14:32:52 2000'), time)
         assert_equal({
           'level' => 'notice',
@@ -174,8 +201,8 @@ module ParserTest
       @parser = TextParser::ApacheParser.new
     end
 
-    def test_call
-      @parser.call('192.168.0.1 - - [28/Feb/2013:12:00:00 +0900] "GET / HTTP/1.1" 200 777 "-" "Opera/12.0"') { |time, record|
+    def test_parse
+      @parser.parse('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,
@@ -206,9 +233,9 @@ module ParserTest
       }
     end
 
-    def test_call
+    def test_parse
       @parser.configure({})
-      @parser.call('Feb 28 12:00:00 192.168.0.1 fluentd[11111]: [error] Syslog test') { |time, record|
+      @parser.parse('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(@expected, record)
       }
@@ -216,18 +243,18 @@ module ParserTest
       assert_equal("%b %d %H:%M:%S", @parser.patterns['time_format'])
     end
 
-    def test_call_with_time_format
+    def test_parse_with_time_format
       @parser.configure('time_format' => '%b %d %M:%S:%H')
-      @parser.call('Feb 28 00:00:12 192.168.0.1 fluentd[11111]: [error] Syslog test') { |time, record|
+      @parser.parse('Feb 28 00:00:12 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(@expected, record)
       }
       assert_equal('%b %d %M:%S:%H', @parser.patterns['time_format'])
     end
 
-    def test_call_with_priority
+    def test_parse_with_priority
       @parser.configure('with_priority' => true)
-      @parser.call('<6>Feb 28 12:00:00 192.168.0.1 fluentd[11111]: [error] Syslog test') { |time, record|
+      @parser.parse('<6>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(@expected.merge('pri' => 6), record)
       }
@@ -235,9 +262,9 @@ module ParserTest
       assert_equal("%b %d %H:%M:%S", @parser.patterns['time_format'])
     end
 
-    def test_call_without_colon
+    def test_parse_without_colon
       @parser.configure({})
-      @parser.call('Feb 28 12:00:00 192.168.0.1 fluentd[11111] [error] Syslog test') { |time, record|
+      @parser.parse('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(@expected, record)
       }
@@ -253,8 +280,8 @@ module ParserTest
       @parser = TextParser::JSONParser.new
     end
 
-    def test_call
-      @parser.call('{"time":1362020400,"host":"192.168.0.1","size":777,"method":"PUT"}') { |time, record|
+    def test_parse
+      @parser.parse('{"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',
@@ -264,10 +291,10 @@ module ParserTest
       }
     end
 
-    def test_call_without_time
+    def test_parse_without_time
       time_at_start = Time.now.to_i
 
-      @parser.call('{"host":"192.168.0.1","size":777,"method":"PUT"}') { |time, record|
+      @parser.parse('{"host":"192.168.0.1","size":777,"method":"PUT"}') { |time, record|
         assert time && time >= time_at_start, "parser puts current time without time input"
         assert_equal({
           'host'   => '192.168.0.1',
@@ -279,7 +306,7 @@ module ParserTest
       parser = TextParser::JSONParser.new
       parser.estimate_current_event = false
       parser.configure({})
-      parser.call('{"host":"192.168.0.1","size":777,"method":"PUT"}') { |time, record|
+      parser.parse('{"host":"192.168.0.1","size":777,"method":"PUT"}') { |time, record|
         assert_equal({
           'host'   => '192.168.0.1',
           'size'   => 777,
@@ -289,9 +316,9 @@ module ParserTest
       }
     end
 
-    def test_call_with_invalid_time
-      assert_raise Fluent::TextParser::ParserError do
-        @parser.call('{"time":[],"k":"v"}') { |time, record| }
+    def test_parse_with_invalid_time
+      assert_raise Fluent::ParserError do
+        @parser.parse('{"time":[],"k":"v"}') { |time, record| }
       end
     end
   end
@@ -314,15 +341,15 @@ module ParserTest
       }
     end
 
-    def test_call
-      @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|
+    def test_parse
+      @parser.parse('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
-      @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|
+    def test_parse_with_empty_included_path
+      @parser.parse('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)
       }
@@ -345,10 +372,10 @@ module ParserTest
       assert_equal ",", parser.delimiter
     end
 
-    def test_call
+    def test_parse
       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|
+      parser.parse("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',
@@ -357,12 +384,12 @@ module ParserTest
       }
     end
 
-    def test_call_with_time
+    def test_parse_with_time
       time_at_start = Time.now.to_i
 
       parser = TextParser::TSVParser.new
       parser.configure('keys' => 'a,b')
-      parser.call("192.168.0.1\t111") { |time, record|
+      parser.parse("192.168.0.1\t111") { |time, record|
         assert time && time >= time_at_start, "parser puts current time without time input"
         assert_equal({
           'a' => '192.168.0.1',
@@ -373,7 +400,7 @@ module ParserTest
       parser = TextParser::TSVParser.new
       parser.estimate_current_event = false
       parser.configure('keys' => 'a,b', 'time_key' => 'time')
-      parser.call("192.168.0.1\t111") { |time, record|
+      parser.parse("192.168.0.1\t111") { |time, record|
         assert_equal({
           'a' => '192.168.0.1',
           'b' => '111',
@@ -381,15 +408,32 @@ module ParserTest
         assert_nil time, "parser returns nil w/o time and if configured so"
       }
     end
+
+    data(
+      'left blank column' => ["\t@\t@", {"1" => "","2" => "@","3" => "@"}],
+      'center blank column' => ["@\t\t@", {"1" => "@","2" => "","3" => "@"}],
+      'right blank column' => ["@\t@\t", {"1" => "@","2" => "@","3" => ""}],
+      '2 right blank columns' => ["@\t\t", {"1" => "@","2" => "","3" => ""}],
+      'left blank columns' => ["\t\t@", {"1" => "","2" => "","3" => "@"}],
+      'all blank columns' => ["\t\t", {"1" => "","2" => "","3" => ""}])
+    def test_black_column(data)
+      line, expected = data
+
+      parser = TextParser::TSVParser.new
+      parser.configure('keys' => '1,2,3')
+      parser.parse(line) { |time, record|
+        assert_equal(expected, record)
+      }
+    end
   end
 
   class CSVParserTest < ::Test::Unit::TestCase
     include ParserTest
 
-    def test_call
+    def test_parse
       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|
+      parser.parse("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',
@@ -398,12 +442,12 @@ module ParserTest
       }
     end
 
-    def test_call_without_time
+    def test_parse_without_time
       time_at_start = Time.now.to_i
 
       parser = TextParser::CSVParser.new
       parser.configure('keys' => 'c,d')
-      parser.call("192.168.0.1,111") { |time, record|
+      parser.parse("192.168.0.1,111") { |time, record|
         assert time && time >= time_at_start, "parser puts current time without time input"
         assert_equal({
           'c' => '192.168.0.1',
@@ -414,7 +458,7 @@ module ParserTest
       parser = TextParser::CSVParser.new
       parser.estimate_current_event = false
       parser.configure('keys' => 'c,d', 'time_key' => 'time')
-      parser.call("192.168.0.1,111") { |time, record|
+      parser.parse("192.168.0.1,111") { |time, record|
         assert_equal({
           'c' => '192.168.0.1',
           'd' => '111',
@@ -442,10 +486,10 @@ module ParserTest
       assert_equal "=", parser.label_delimiter
     end
 
-    def test_call
+    def test_parse
       parser = TextParser::LabeledTSVParser.new
       parser.configure({})
-      parser.call("time:2013/02/28 12:00:00\thost:192.168.0.1\treq_id:111") { |time, record|
+      parser.parse("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',
@@ -454,13 +498,13 @@ module ParserTest
       }
     end
 
-    def test_call_with_customized_delimiter
+    def test_parse_with_customized_delimiter
       parser = TextParser::LabeledTSVParser.new
       parser.configure(
         'delimiter'       => ',',
         'label_delimiter' => '=',
       )
-      parser.call('time=2013/02/28 12:00:00,host=192.168.0.1,req_id=111') { |time, record|
+      parser.parse('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',
@@ -469,13 +513,13 @@ module ParserTest
       }
     end
 
-    def test_call_with_customized_time_format
+    def test_parse_with_customized_time_format
       parser = TextParser::LabeledTSVParser.new
       parser.configure(
         'time_key'    => 'mytime',
         'time_format' => '%d/%b/%Y:%H:%M:%S %z',
       )
-      parser.call("mytime:28/Feb/2013:12:00:00 +0900\thost:192.168.0.1\treq_id:111") { |time, record|
+      parser.parse("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',
@@ -484,12 +528,12 @@ module ParserTest
       }
     end
 
-    def test_call_without_time
+    def test_parse_without_time
       time_at_start = Time.now.to_i
 
       parser = TextParser::LabeledTSVParser.new
       parser.configure({})
-      parser.call("host:192.168.0.1\treq_id:111") { |time, record|
+      parser.parse("host:192.168.0.1\treq_id:111") { |time, record|
         assert time && time >= time_at_start, "parser puts current time without time input"
         assert_equal({
           'host'   => '192.168.0.1',
@@ -500,7 +544,7 @@ module ParserTest
       parser = TextParser::LabeledTSVParser.new
       parser.estimate_current_event = false
       parser.configure({})
-      parser.call("host:192.168.0.1\treq_id:111") { |time, record|
+      parser.parse("host:192.168.0.1\treq_id:111") { |time, record|
         assert_equal({
           'host'   => '192.168.0.1',
           'req_id' => '111',
@@ -522,28 +566,28 @@ module ParserTest
       assert_equal "foobar", parser.message_key
     end
 
-    def test_call
+    def test_parse
       parser = TextParser::TEMPLATE_REGISTRY.lookup('none').call
       parser.configure({})
-      parser.call('log message!') { |time, record|
+      parser.parse('log message!') { |time, record|
         assert_equal({'message' => 'log message!'}, record)
       }
     end
 
-    def test_call_with_message_key
+    def test_parse_with_message_key
       parser = TextParser::NoneParser.new
       parser.configure('message_key' => 'foobar')
-      parser.call('log message!') { |time, record|
+      parser.parse('log message!') { |time, record|
         assert_equal({'foobar' => 'log message!'}, record)
       }
     end
 
-    def test_call_without_default_time
+    def test_parse_without_default_time
       time_at_start = Time.now.to_i
 
       parser = TextParser::TEMPLATE_REGISTRY.lookup('none').call
       parser.configure({})
-      parser.call('log message!') { |time, record|
+      parser.parse('log message!') { |time, record|
         assert time && time >= time_at_start, "parser puts current time without time input"
         assert_equal({'message' => 'log message!'}, record)
       }
@@ -551,7 +595,7 @@ module ParserTest
       parser = TextParser::TEMPLATE_REGISTRY.lookup('none').call
       parser.estimate_current_event = false
       parser.configure({})
-      parser.call('log message!') { |time, record|
+      parser.parse('log message!') { |time, record|
         assert_equal({'message' => 'log message!'}, record)
         assert_nil time, "parser returns nil w/o time if configured so"
       }
@@ -575,9 +619,9 @@ module ParserTest
       }
     end
 
-    def test_call
+    def test_parse
       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>.*)/')
-      parser.call(<<EOS.chomp) { |time, record|
+      parser.parse(<<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]
@@ -592,9 +636,9 @@ EOS
       }
     end
 
-    def test_call_with_firstline
+    def test_parse_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>.*)/')
-      parser.call(<<EOS.chomp) { |time, record|
+      parser.parse(<<EOS.chomp) { |time, record|
 ----
 time=2013-3-03 14:27:33 
 message=test1
@@ -606,7 +650,7 @@ EOS
       }
     end
 
-    def test_call_with_multiple_formats
+    def test_parse_with_multiple_formats
       parser = create_parser('format_firstline' => '/^Started/',
         'format1' => '/Started (?<method>[^ ]+) "(?<path>[^"]+)" for (?<host>[^ ]+) at (?<time>[^ ]+ [^ ]+ [^ ]+)\n/',
         'format2' => '/Processing by (?<controller>[^\u0023]+)\u0023(?<controller_method>[^ ]+) as (?<format>[^ ]+?)\n/',
@@ -614,7 +658,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\)/'
         )
-      parser.call(<<EOS.chomp) { |time, record|
+      parser.parse(<<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"}
@@ -646,10 +690,10 @@ EOS
   class TextParserTest < ::Test::Unit::TestCase
     include ParserTest
 
-    class MultiEventTestParser
+    class MultiEventTestParser < ::Fluent::Parser
       include Fluent::Configurable
 
-      def call(text)
+      def parse(text)
         2.times { |i|
           record = {}
           record['message'] = text