diff --git a/lib/fluent/parser.rb b/lib/fluent/parser.rb
index d61c163419..1e3b92990e 100644
--- a/lib/fluent/parser.rb
+++ b/lib/fluent/parser.rb
@@ -367,6 +367,83 @@ def call(text)
       end
     end
 
+    class MultilineParser
+      include Configurable
+
+      config_param :format_firstline, :string, :default => nil
+
+      FORMAT_MAX_NUM = 20
+
+      def configure(conf)
+        super
+
+        formats = parse_formats(conf).compact.map { |f| f[1..-2] }.join
+        begin
+          @regex = Regexp.new(formats, Regexp::MULTILINE)
+          if @regex.named_captures.empty?
+            raise "No named captures"
+          end
+          @parser = RegexpParser.new(@regex, conf)
+        rescue => e
+          raise ConfigError, "Invalid regexp '#{formats}': #{e}"
+        end
+
+        if @format_firstline
+          check_format_regexp(@format_firstline, 'format_firstline')
+          @regex = Regexp.new(@format_firstline[1..-2])
+        end
+      end
+
+      def call(text)
+        @parser.call(text)
+      end
+
+      def firstline?(text)
+        @regex.match(text)
+      end
+
+      private
+
+      def parse_formats(conf)
+        check_format_range(conf)
+
+        prev_format = nil
+        (1..FORMAT_MAX_NUM).map { |i|
+          format = conf["format#{i}"]
+          if (i > 1) && prev_format.nil? && !format.nil?
+            raise ConfigError, "Jump of format index found. format#{i - 1} is missing."
+          end
+          prev_format = format
+          next if format.nil?
+
+          check_format_regexp(format, "format#{i}")
+          format
+        }
+      end
+
+      def check_format_range(conf)
+        invalid_formats = conf.keys.select { |k|
+          m = k.match(/^format(\d+)$/)
+          m ? !((1..FORMAT_MAX_NUM).include?(m[1].to_i)) : false
+        }
+        unless invalid_formats.empty?
+          raise ConfigError, "Invalid formatN found. N should be 1 - #{FORMAT_MAX_NUM}: " + invalid_formats.join(",")
+        end
+      end
+
+      def check_format_regexp(format, key)
+        if format[0] == '/' && format[-1] == '/'
+          begin
+            Regexp.new(format[1..-2], Regexp::MULTILINE)
+          rescue => e
+            raise ConfigError, "Invalid regexp in #{key}: #{e}"
+          end
+        else
+          raise ConfigError, "format should be Regexp, need //, in #{key}: '#{format}'"
+        end
+      end
+    end
+
     TEMPLATE_FACTORIES = {
       'apache' => Proc.new { RegexpParser.new(/^(?<host>[^ ]*) [^ ]* (?<user>[^ ]*) \[(?<time>[^\]]*)\] "(?<method>\S+)(?: +(?<path>[^ ]*) +\S*)?" (?<code>[^ ]*) (?<size>[^ ]*)(?: "(?<referer>[^\"]*)" "(?<agent>[^\"]*)")?$/, {'time_format'=>"%d/%b/%Y:%H:%M:%S %z"}) },
       'apache2' => Proc.new { ApacheParser.new },
@@ -377,6 +454,7 @@ def call(text)
       'csv' => Proc.new { CSVParser.new },
       'nginx' => Proc.new { RegexpParser.new(/^(?<remote>[^ ]*) (?<host>[^ ]*) (?<user>[^ ]*) \[(?<time>[^\]]*)\] "(?<method>\S+)(?: +(?<path>[^\"]*) +\S*)?" (?<code>[^ ]*) (?<size>[^ ]*)(?: "(?<referer>[^\"]*)" "(?<agent>[^\"]*)")?$/,  {'time_format'=>"%d/%b/%Y:%H:%M:%S %z"}) },
       'none' => Proc.new { NoneParser.new },
+      'multiline' => Proc.new { MultilineParser.new },
     }
 
     def self.register_template(name, regexp_or_proc, time_format=nil)
@@ -394,6 +472,8 @@ def initialize
       @parser = nil
     end
 
+    attr_reader :parser
+
     def configure(conf, required=true)
       format = conf['format']
 
diff --git a/lib/fluent/plugin/in_tail.rb b/lib/fluent/plugin/in_tail.rb
index 5a45c1a3a0..144e21700a 100644
--- a/lib/fluent/plugin/in_tail.rb
+++ b/lib/fluent/plugin/in_tail.rb
@@ -16,7 +16,7 @@
 #    limitations under the License.
 #
 module Fluent
-  class TailInput < Input
+  class NewTailInput < Input
     Plugin.register_input('tail', self)
 
     def initialize
@@ -31,6 +31,569 @@ def initialize
 
     attr_reader :paths
 
+    def configure(conf)
+      super
+
+      @paths = @path.split(',').map {|path| path.strip }
+      if @paths.empty?
+        raise ConfigError, "tail: 'path' parameter is required on tail input"
+      end
+
+      unless @pos_file
+        $log.warn "'pos_file PATH' parameter is not set to a 'tail' source."
+        $log.warn "this parameter is highly recommended to save the position to resume tailing."
+      end
+
+      configure_parser(conf)
+
+      @multiline_mode = conf['format'] == 'multiline'
+      @receive_handler = if @multiline_mode
+                           method(:parse_multilines)
+                         else
+                           method(:parse_singleline)
+                         end
+    end
+
+    def configure_parser(conf)
+      @parser = TextParser.new
+      @parser.configure(conf)
+    end
+
+    def start
+      if @pos_file
+        @pf_file = File.open(@pos_file, File::RDWR|File::CREAT, DEFAULT_FILE_PERMISSION)
+        @pf_file.sync = true
+        @pf = PositionFile.parse(@pf_file)
+      end
+
+      @loop = Coolio::Loop.new
+      @tails = @paths.map {|path|
+        pe = @pf ? @pf[path] : MemoryPositionEntry.new
+        tw = TailWatcher.new(path, @rotate_wait, pe, &method(:receive_lines))
+        tw.log = log
+        tw
+      }
+      @tails.each {|tail|
+        tail.attach(@loop)
+      }
+      @thread = Thread.new(&method(:run))
+    end
+
+    def shutdown
+      @tails.each {|tail|
+        tail.close
+      }
+      @loop.stop
+      @thread.join
+
+      flush_buffer if @multiline_mode
+      @pf_file.close if @pf_file
+    end
+
+    def flush_buffer
+      @tails.each { |tail|
+        if lb = tail.line_buffer
+          lb.chomp!
+          time, record = parse_line(lb)
+          if time && record
+            Engine.emit(@tag, time, record)
+          else
+            log.warn "got incomplete line at shutdown from #{tail.path}: #{lb.inspect}"
+          end
+        end
+      }
+    end
+
+    def run
+      @loop.run
+    rescue
+      log.error "unexpected error", :error=>$!.to_s
+      log.error_backtrace
+    end
+
+    def receive_lines(lines, tail_watcher)
+      es = @receive_handler.call(lines, tail_watcher)
+      unless es.empty?
+        begin
+          Engine.emit_stream(@tag, es)
+        rescue
+          # ignore errors. Engine shows logs and backtraces.
+        end
+      end
+    end
+
+    def parse_line(line)
+      return @parser.parse(line)
+    end
+
+    def convert_line_to_event(line, es)
+      begin
+        line.chomp!  # remove \n
+        time, record = parse_line(line)
+        if time && record
+          es.add(time, record)
+        else
+          log.warn "pattern not match: #{line.inspect}"
+        end
+      rescue => e
+        log.warn line.dump, :error => e.to_s
+        log.debug_backtrace(e)
+      end
+    end
+
+    def parse_singleline(lines, tail_watcher)
+      es = MultiEventStream.new
+      lines.each { |line|
+        convert_line_to_event(line, es)
+      }
+      es
+    end
+
+    def parse_multilines(lines, tail_watcher)
+      lb = tail_watcher.line_buffer
+      es = MultiEventStream.new
+      lines.each { |line|
+        if @parser.parser.firstline?(line)
+          if lb
+            convert_line_to_event(lb, es)
+          end
+          lb = line
+        else
+          if lb.nil?
+            log.warn "got incomplete line before first line from #{tail_watcher.path}: #{lb.inspect}"
+          else
+            lb << line
+          end
+        end
+      }
+      tail_watcher.line_buffer = lb
+      es
+    end
+
+    class TailWatcher
+      def initialize(path, rotate_wait, pe, &receive_lines)
+        @path = path
+        @rotate_wait = rotate_wait
+        @pe = pe || MemoryPositionEntry.new
+        @receive_lines = receive_lines
+
+        @rotate_queue = []
+
+        @timer_trigger = TimerWatcher.new(1, true, &method(:on_notify))
+        @stat_trigger = StatWatcher.new(path, &method(:on_notify))
+
+        @rotate_handler = RotateHandler.new(path, &method(:on_rotate))
+        @io_handler = nil
+        @log = $log
+      end
+
+      attr_reader :path
+      attr_accessor :line_buffer
+
+      # We use accessor approach to assign each logger, not passing log object at initialization,
+      # because several plugins depend on these internal classes.
+      # This approach avoids breaking plugins with new log_level option.
+      attr_accessor :log
+
+      def log=(logger)
+        @log = logger
+        @timer_trigger.log = logger
+        @stat_trigger.log = logger
+        @rotate_handler.log = logger
+      end
+
+      def wrap_receive_lines(lines)
+        @receive_lines.call(lines, self)
+      end
+
+      def attach(loop)
+        @timer_trigger.attach(loop)
+        @stat_trigger.attach(loop)
+        on_notify
+      end
+
+      def detach
+        @timer_trigger.detach if @timer_trigger.attached?
+        @stat_trigger.detach if @stat_trigger.attached?
+      end
+
+      def close
+        @rotate_queue.reject! {|req|
+          req.io.close
+          true
+        }
+        detach
+      end
+
+      def on_notify
+        @rotate_handler.on_notify
+        return unless @io_handler
+        @io_handler.on_notify
+
+        # proceeds rotate queue
+        return if @rotate_queue.empty?
+        @rotate_queue.first.tick
+
+        while @rotate_queue.first.ready?
+          if io = @rotate_queue.first.io
+            stat = io.stat
+            inode = stat.ino
+            if inode == @pe.read_inode
+              # rotated file has the same inode number with the last file.
+              # assuming following situation:
+              #   a) file was once renamed and backed, or
+              #   b) symlink or hardlink to the same file is recreated
+              # in either case, seek to the saved position
+              pos = @pe.read_pos
+            else
+              pos = io.pos
+            end
+            @pe.update(inode, pos)
+            io_handler = IOHandler.new(io, @pe, log, &method(:wrap_receive_lines))
+          else
+            io_handler = NullIOHandler.new
+          end
+          @io_handler.close
+          @io_handler = io_handler
+          @rotate_queue.shift
+          break if @rotate_queue.empty?
+        end
+      end
+
+      def on_rotate(io)
+        if @io_handler == nil
+          if io
+            # first time
+            stat = io.stat
+            fsize = stat.size
+            inode = stat.ino
+
+            last_inode = @pe.read_inode
+            if inode == last_inode
+              # seek to the saved position
+              pos = @pe.read_pos
+            elsif last_inode != 0
+              # this is FilePositionEntry and fluentd once started.
+              # read data from the head of the rotated file.
+              # logs never duplicate because this file is a rotated new file.
+              pos = 0
+              @pe.update(inode, pos)
+            else
+              # this is MemoryPositionEntry or this is the first time fluentd started.
+              # seek to the end of the any files.
+              # logs may duplicate without this seek because it's not sure the file is
+              # existent file or rotated new file.
+              pos = fsize
+              @pe.update(inode, pos)
+            end
+            io.seek(pos)
+
+            @io_handler = IOHandler.new(io, @pe, log, &method(:wrap_receive_lines))
+          else
+            @io_handler = NullIOHandler.new
+          end
+
+        else
+          if io && @rotate_queue.find {|req| req.io == io }
+            return
+          end
+          last_io = @rotate_queue.empty? ? @io_handler.io : @rotate_queue.last.io
+          if last_io == nil
+            log.info "detected rotation of #{@path}"
+            # rotate imeediately if previous file is nil
+            wait = 0
+          else
+            log.info "detected rotation of #{@path}; waiting #{@rotate_wait} seconds"
+            wait = @rotate_wait
+            wait -= @rotate_queue.first.wait unless @rotate_queue.empty?
+          end
+          @rotate_queue << RotationRequest.new(io, wait)
+        end
+      end
+
+      class TimerWatcher < Coolio::TimerWatcher
+        def initialize(interval, repeat, &callback)
+          @callback = callback
+          @log = $log
+          super(interval, repeat)
+        end
+
+        attr_accessor :log
+
+        def on_timer
+          @callback.call
+        rescue
+          # TODO log?
+          @log.error $!.to_s
+          @log.error_backtrace
+        end
+      end
+
+      class StatWatcher < Coolio::StatWatcher
+        def initialize(path, &callback)
+          @callback = callback
+          @log = $log
+          super(path)
+        end
+
+        attr_accessor :log
+
+        def on_change(prev, cur)
+          @callback.call
+        rescue
+          # TODO log?
+          @log.error $!.to_s
+          @log.error_backtrace
+        end
+      end
+
+      class RotationRequest
+        def initialize(io, wait)
+          @io = io
+          @wait = wait
+        end
+
+        attr_reader :io, :wait
+
+        def tick
+          @wait -= 1
+        end
+
+        def ready?
+          @wait <= 0
+        end
+      end
+
+      MAX_LINES_AT_ONCE = 1000
+
+      class IOHandler
+        def initialize(io, pe, log, &receive_lines)
+          @log = log
+          @log.info "following tail of #{io.path}"
+          @io = io
+          @pe = pe
+          @receive_lines = receive_lines
+          @buffer = ''.force_encoding('ASCII-8BIT')
+          @iobuf = ''.force_encoding('ASCII-8BIT')
+        end
+
+        attr_reader :io
+
+        def on_notify
+          begin
+            lines = []
+            read_more = false
+
+            begin
+              while true
+                if @buffer.empty?
+                  @io.read_nonblock(2048, @buffer)
+                else
+                  @buffer << @io.read_nonblock(2048, @iobuf)
+                end
+                while line = @buffer.slice!(/.*?\n/m)
+                  lines << line
+                end
+                if lines.size >= MAX_LINES_AT_ONCE
+                  # not to use too much memory in case the file is very large
+                  read_more = true
+                  break
+                end
+              end
+            rescue EOFError
+            end
+
+            unless lines.empty?
+              @receive_lines.call(lines)
+              @pe.update_pos(@io.pos - @buffer.bytesize)
+            end
+          end while read_more
+
+        rescue
+          @log.error $!.to_s
+          @log.error_backtrace
+          close
+        end
+
+        def close
+          @io.close unless @io.closed?
+        end
+      end
+
+      class NullIOHandler
+        def initialize
+        end
+
+        def io
+        end
+
+        def on_notify
+        end
+
+        def close
+        end
+      end
+
+      class RotateHandler
+        def initialize(path, &on_rotate)
+          @path = path
+          @inode = nil
+          @fsize = -1  # first
+          @on_rotate = on_rotate
+          @log = $log
+        end
+
+        attr_accessor :log
+
+        def on_notify
+          begin
+            io = File.open(@path)
+            stat = io.stat
+            inode = stat.ino
+            fsize = stat.size
+          rescue Errno::ENOENT
+            # moved or deleted
+            inode = nil
+            fsize = 0
+          end
+
+          begin
+            if @inode != inode || fsize < @fsize
+              # rotated or truncated
+              @on_rotate.call(io)
+              io = nil
+            end
+
+            @inode = inode
+            @fsize = fsize
+          ensure
+            io.close if io
+          end
+
+        rescue
+          @log.error $!.to_s
+          @log.error_backtrace
+        end
+      end
+    end
+
+
+    class PositionFile
+      def initialize(file, map, last_pos)
+        @file = file
+        @map = map
+        @last_pos = last_pos
+      end
+
+      def [](path)
+        if m = @map[path]
+          return m
+        end
+
+        @file.pos = @last_pos
+        @file.write path
+        @file.write "\t"
+        seek = @file.pos
+        @file.write "0000000000000000\t00000000\n"
+        @last_pos = @file.pos
+
+        @map[path] = FilePositionEntry.new(@file, seek)
+      end
+
+      def self.parse(file)
+        map = {}
+        file.pos = 0
+        file.each_line {|line|
+          m = /^([^\t]+)\t([0-9a-fA-F]+)\t([0-9a-fA-F]+)/.match(line)
+          next unless m
+          path = m[1]
+          pos = m[2].to_i(16)
+          ino = m[3].to_i(16)
+          seek = file.pos - line.bytesize + path.bytesize + 1
+          map[path] = FilePositionEntry.new(file, seek)
+        }
+        new(file, map, file.pos)
+      end
+    end
+
+    # pos               inode
+    # ffffffffffffffff\tffffffff\n
+    class FilePositionEntry
+      POS_SIZE = 16
+      INO_OFFSET = 17
+      INO_SIZE = 8
+      LN_OFFSET = 25
+      SIZE = 26
+
+      def initialize(file, seek)
+        @file = file
+        @seek = seek
+      end
+
+      def update(ino, pos)
+        @file.pos = @seek
+        @file.write "%016x\t%08x" % [pos, ino]
+        @inode = ino
+      end
+
+      def update_pos(pos)
+        @file.pos = @seek
+        @file.write "%016x" % pos
+      end
+
+      def read_inode
+        @file.pos = @seek + INO_OFFSET
+        raw = @file.read(8)
+        raw ? raw.to_i(16) : 0
+      end
+
+      def read_pos
+        @file.pos = @seek
+        raw = @file.read(16)
+        raw ? raw.to_i(16) : 0
+      end
+    end
+
+    class MemoryPositionEntry
+      def initialize
+        @pos = 0
+        @inode = 0
+      end
+
+      def update(ino, pos)
+        @inode = ino
+        @pos = pos
+      end
+
+      def update_pos(pos)
+        @pos = pos
+      end
+
+      def read_pos
+        @pos
+      end
+
+      def read_inode
+        @inode
+      end
+    end
+  end
+
+  # This TailInput is for existence plugins which extends old in_tail
+  # This class will be removed after release v1.
+  class TailInput < Input
+    def initialize
+      super
+      @paths = []
+    end
+
+    config_param :path, :string
+    config_param :tag, :string
+    config_param :rotate_wait, :time, :default => 5
+    config_param :pos_file, :string, :default => nil
+
+    attr_reader :paths
+
     def configure(conf)
       super
 
diff --git a/test/parser.rb b/test/parser.rb
index be3e19af32..828fa4a24a 100644
--- a/test/parser.rb
+++ b/test/parser.rb
@@ -282,4 +282,85 @@ def test_call_with_message_key
     end
   end
 
+  class MultilineParserTest < ::Test::Unit::TestCase
+    include ParserTest
+
+    def create_parser(conf)
+      parser = TextParser::TEMPLATE_FACTORIES['multiline'].call
+      parser.configure(conf)
+      parser
+    end
+
+    def test_configure_with_invalid_params
+      [{'format100' => '/(?<msg>.*)/'}, {'format1' => '/(?<msg>.*)/', 'format3' => '/(?<msg>.*)/'}, 'format1' => '/(?<msg>.*)'].each { |config|
+        assert_raise(ConfigError) {
+          create_parser(config)
+        }
+      }
+    end
+
+    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)
+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)
+    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)
+----
+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)
+    end
+
+    def test_call_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/',
+        'format3' => '/(  Parameters: (?<parameters>[^ ]+)\n)?/',
+        '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)
+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"}
+  Rendered users/show.html.erb within layouts/application (0.3ms)
+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)
+    end
+  end
 end
diff --git a/test/plugin/in_tail.rb b/test/plugin/in_tail.rb
index b8611ee57f..dbdfecb5fe 100644
--- a/test/plugin/in_tail.rb
+++ b/test/plugin/in_tail.rb
@@ -10,16 +10,19 @@ def setup
 
   TMP_DIR = File.dirname(__FILE__) + "/../tmp/tail#{ENV['TEST_ENV_NUMBER']}"
 
-  CONFIG = %[
+  COMMON_CONFIG = %[
     path #{TMP_DIR}/tail.txt
     tag t1
     rotate_wait 2s
     pos_file #{TMP_DIR}/tail.pos
+  ]
+  SINGLE_LINE_CONFIG = %[
     format /(?<message>.*)/
   ]
 
-  def create_driver(conf=CONFIG)
-    Fluent::Test::InputTestDriver.new(Fluent::TailInput).configure(conf)
+  def create_driver(conf = SINGLE_LINE_CONFIG, use_common_conf = true)
+    config = use_common_conf ? COMMON_CONFIG + conf : conf
+    Fluent::Test::InputTestDriver.new(Fluent::NewTailInput).configure(config)
   end
 
   def test_configure
@@ -104,4 +107,100 @@ def test_whitespace
     assert_equal({"message"=>"	tab"}, emits[4][2])
     assert_equal({"message"=>"tab	"}, emits[5][2])
   end
+
+  # multiline mode test
+
+  def test_multiline
+    File.open("#{TMP_DIR}/tail.txt", "w") { |f| }
+
+    d = create_driver %[
+      format multiline
+      format1 /^s (?<message1>[^\\n]+)(\\nf (?<message2>[^\\n]+))?(\\nf (?<message3>.*))?/
+      format_firstline /^[s]/
+    ]
+    d.run do
+      File.open("#{TMP_DIR}/tail.txt", "a") { |f|
+        f.puts "f test1"
+        f.puts "s test2"
+        f.puts "f test3"
+        f.puts "f test4"
+        f.puts "s test5"
+        f.puts "s test6"
+        f.puts "f test7"
+        f.puts "s test8"
+      }
+      sleep 1
+    end
+
+    emits = d.emits
+    assert(emits.length > 0)
+    assert_equal({"message1" => "test2", "message2" => "test3", "message3" => "test4"}, emits[0][2])
+    assert_equal({"message1" => "test5"}, emits[1][2])
+    assert_equal({"message1" => "test6", "message2" => "test7"}, emits[2][2])
+    assert_equal({"message1" => "test8"}, emits[3][2])
+  end
+  
+  def test_multiline_with_multiple_formats
+    File.open("#{TMP_DIR}/tail.txt", "w") { |f| }
+
+    d = create_driver %[
+      format multiline
+      format1 /^s (?<message1>[^\\n]+)\\n?/
+      format2 /(f (?<message2>[^\\n]+)\\n?)?/
+      format3 /(f (?<message3>.*))?/
+      format_firstline /^[s]/
+    ]
+    d.run do
+      File.open("#{TMP_DIR}/tail.txt", "a") { |f|
+        f.puts "f test1"
+        f.puts "s test2"
+        f.puts "f test3"
+        f.puts "f test4"
+        f.puts "s test5"
+        f.puts "s test6"
+        f.puts "f test7"
+        f.puts "s test8"
+      }
+      sleep 1
+    end
+
+    emits = d.emits
+    assert(emits.length > 0)
+    assert_equal({"message1" => "test2", "message2" => "test3", "message3" => "test4"}, emits[0][2])
+    assert_equal({"message1" => "test5"}, emits[1][2])
+    assert_equal({"message1" => "test6", "message2" => "test7"}, emits[2][2])
+    assert_equal({"message1" => "test8"}, emits[3][2])
+  end
+
+  def test_multilinelog_with_multiple_paths
+    files = ["#{TMP_DIR}/tail1.txt", "#{TMP_DIR}/tail2.txt"]
+    files.each { |file| File.open(file, "w") { |f| } }
+
+    d = create_driver(%[
+      path #{files[0]},#{files[1]}
+      tag t1
+      format multiline
+      format1 /^[s|f] (?<message>.*)/
+      format_firstline /^[s]/
+    ], false)
+    d.run do
+      files.each do |file|
+        File.open(file, 'a') { |f|
+          f.puts "f #{file} line should be ignored"
+          f.puts "s test1"
+          f.puts "f test2"
+          f.puts "f test3"
+          f.puts "s test4"
+        }
+      end
+      sleep 1
+    end
+
+    emits = d.emits
+    assert_equal({"message" => "test1\nf test2\nf test3"}, emits[0][2])
+    assert_equal({"message" => "test1\nf test2\nf test3"}, emits[1][2])
+    # "test4" events are here because these events are flushed at shutdown phase
+    assert_equal({"message" => "test4"}, emits[2][2])
+    assert_equal({"message" => "test4"}, emits[3][2])
+  end
 end