fluentd 1.13.0-x64-mingw32 → 1.14.0-x64-mingw32

data/test/plugin/test_in_syslog.rb

@@ -5,42 +5,51 @@ require 'fluent/plugin/in_syslog'
 class SyslogInputTest < Test::Unit::TestCase
   def setup
     Fluent::Test.setup
+    @port = unused_port
   end
 
-  PORT = unused_port
-  CONFIG = %[
-    port #{PORT}
-    bind 127.0.0.1
-    tag syslog
-  ]
+  def teardown
+    @port = nil
+  end
+
+  def ipv4_config
+    %[
+      port #{@port}
+      bind 127.0.0.1
+      tag syslog
+    ]
+  end
 
-  IPv6_CONFIG = %[
-    port #{PORT}
-    bind ::1
-    tag syslog
-  ]
+  def ipv6_config
+    %[
+      port #{@port}
+      bind ::1
+      tag syslog
+    ]
+  end
 
-  def create_driver(conf=CONFIG)
+  def create_driver(conf=ipv4_config)
     Fluent::Test::Driver::Input.new(Fluent::Plugin::SyslogInput).configure(conf)
   end
 
   data(
-    ipv4: ['127.0.0.1', CONFIG, ::Socket::AF_INET],
-    ipv6: ['::1', IPv6_CONFIG, ::Socket::AF_INET6],
+    ipv4: ['127.0.0.1', :ipv4, ::Socket::AF_INET],
+    ipv6: ['::1', :ipv6, ::Socket::AF_INET6],
   )
   def test_configure(data)
-    bind_addr, config, family = data
+    bind_addr, protocol, family = data
+    config = send("#{protocol}_config")
     omit "IPv6 unavailable" if family == ::Socket::AF_INET6 && !ipv6_enabled?
 
     d = create_driver(config)
-    assert_equal PORT, d.instance.port
+    assert_equal @port, d.instance.port
     assert_equal bind_addr, d.instance.bind
   end
 
   sub_test_case 'source_hostname_key and source_address_key features' do
     test 'resolve_hostname must be true with source_hostname_key' do
       assert_raise(Fluent::ConfigError) {
-        create_driver(CONFIG + <<EOS)
+        create_driver(ipv4_config + <<EOS)
 resolve_hostname false
 source_hostname_key hostname
 EOS
@@ -50,7 +59,7 @@ EOS
     data('resolve_hostname' => 'resolve_hostname true',
          'source_hostname_key' => 'source_hostname_key source_host')
     def test_configure_resolve_hostname(param)
-      d = create_driver([CONFIG, param].join("\n"))
+      d = create_driver([ipv4_config, param].join("\n"))
       assert_true d.instance.resolve_hostname
     end
   end
@@ -60,7 +69,7 @@ EOS
        'Use transport and protocol' => ["protocol_type udp\n<transport tcp>\n </transport>", :udp, :tcp])
   def test_configure_protocol(param)
     conf, proto_type, transport_proto_type = *param
-    d = create_driver([CONFIG, conf].join("\n"))
+    d = create_driver([ipv4_config, conf].join("\n"))
 
     assert_equal(d.instance.protocol_type, proto_type)
     assert_equal(d.instance.transport_config.protocol, transport_proto_type)
@@ -68,12 +77,12 @@ EOS
 
   # For backward compat
   def test_respect_protocol_type_than_transport
-    d = create_driver([CONFIG, "<transport tcp> \n</transport>", "protocol_type udp"].join("\n"))
+    d = create_driver([ipv4_config, "<transport tcp> \n</transport>", "protocol_type udp"].join("\n"))
     tests = create_test_case
 
     d.run(expect_emits: 2) do
       u = UDPSocket.new
-      u.connect('127.0.0.1', PORT)
+      u.connect('127.0.0.1', @port)
       tests.each {|test|
         u.send(test['msg'], 0)
       }
@@ -85,11 +94,12 @@ EOS
 
 
   data(
-    ipv4: ['127.0.0.1', CONFIG, ::Socket::AF_INET],
-    ipv6: ['::1', IPv6_CONFIG, ::Socket::AF_INET6],
+    ipv4: ['127.0.0.1', :ipv4, ::Socket::AF_INET],
+    ipv6: ['::1', :ipv6, ::Socket::AF_INET6],
   )
   def test_time_format(data)
-    bind_addr, config, family = data
+    bind_addr, protocol, family = data
+    config = send("#{protocol}_config")
     omit "IPv6 unavailable" if family == ::Socket::AF_INET6 && !ipv6_enabled?
 
     d = create_driver(config)
@@ -100,7 +110,7 @@ EOS
     ]
     d.run(expect_emits: 2) do
       u = UDPSocket.new(family)
-      u.connect(bind_addr, PORT)
+      u.connect(bind_addr, @port)
       tests.each {|test|
         u.send(test['msg'], 0)
       }
@@ -119,7 +129,7 @@ EOS
 
     d.run(expect_emits: 2) do
       u = UDPSocket.new
-      u.connect('127.0.0.1', PORT)
+      u.connect('127.0.0.1', @port)
       tests.each {|test|
         u.send(test['msg'], 0)
       }
@@ -130,14 +140,14 @@ EOS
   end
 
   def test_msg_size_udp_for_large_msg
-    d = create_driver(CONFIG + %[
+    d = create_driver(ipv4_config + %[
       message_length_limit 5k
     ])
     tests = create_test_case(large_message: true)
 
     d.run(expect_emits: 3) do
       u = UDPSocket.new
-      u.connect('127.0.0.1', PORT)
+      u.connect('127.0.0.1', @port)
       tests.each {|test|
         u.send(test['msg'], 0)
       }
@@ -148,12 +158,12 @@ EOS
   end
 
   def test_msg_size_with_tcp
-    d = create_driver([CONFIG, "<transport tcp> \n</transport>"].join("\n"))
+    d = create_driver([ipv4_config, "<transport tcp> \n</transport>"].join("\n"))
     tests = create_test_case
 
     d.run(expect_emits: 2) do
       tests.each {|test|
-        TCPSocket.open('127.0.0.1', PORT) do |s|
+        TCPSocket.open('127.0.0.1', @port) do |s|
           s.send(test['msg'], 0)
         end
       }
@@ -164,12 +174,12 @@ EOS
   end
 
   def test_emit_rfc5452
-    d = create_driver([CONFIG, "facility_key pri\n<parse>\n message_format rfc5424\nwith_priority true\n</parse>"].join("\n"))
+    d = create_driver([ipv4_config, "facility_key pri\n<parse>\n message_format rfc5424\nwith_priority true\n</parse>"].join("\n"))
     msg = '<1>1 2017-02-06T13:14:15.003Z myhostname 02abaf0687f5 10339 02abaf0687f5 - method=POST db=0.00'
 
     d.run(expect_emits: 1, timeout: 2) do
       u = UDPSocket.new
-      u.connect('127.0.0.1', PORT)
+      u.connect('127.0.0.1', @port)
       u.send(msg, 0)
     end
 
@@ -179,11 +189,11 @@ EOS
   end
 
   def test_msg_size_with_same_tcp_connection
-    d = create_driver([CONFIG, "<transport tcp> \n</transport>"].join("\n"))
+    d = create_driver([ipv4_config, "<transport tcp> \n</transport>"].join("\n"))
     tests = create_test_case
 
     d.run(expect_emits: 2) do
-      TCPSocket.open('127.0.0.1', PORT) do |s|
+      TCPSocket.open('127.0.0.1', @port) do |s|
         tests.each {|test|
           s.send(test['msg'], 0)
         }
@@ -195,7 +205,7 @@ EOS
   end
 
   def test_msg_size_with_json_format
-    d = create_driver([CONFIG, 'format json'].join("\n"))
+    d = create_driver([ipv4_config, 'format json'].join("\n"))
     time = Time.parse('2013-09-18 12:00:00 +0900').to_i
     tests = ['Hello!', 'Syslog!'].map { |msg|
       event = {'time' => time, 'message' => msg}
@@ -204,7 +214,7 @@ EOS
 
     d.run(expect_emits: 2) do
       u = UDPSocket.new
-      u.connect('127.0.0.1', PORT)
+      u.connect('127.0.0.1', @port)
       tests.each {|test|
         u.send(test['msg'], 0)
       }
@@ -215,13 +225,13 @@ EOS
   end
 
   def test_msg_size_with_include_source_host
-    d = create_driver([CONFIG, 'include_source_host true'].join("\n"))
+    d = create_driver([ipv4_config, 'include_source_host true'].join("\n"))
     tests = create_test_case
 
     host = nil
     d.run(expect_emits: 2) do
       u = UDPSocket.new
-      u.connect('127.0.0.1', PORT)
+      u.connect('127.0.0.1', @port)
       host = u.peeraddr[2]
       tests.each {|test|
         u.send(test['msg'], 0)
@@ -237,13 +247,13 @@ EOS
     priority_key: 'priority_key',
   )
   def test_msg_size_with_severity_key(param_name)
-    d = create_driver([CONFIG, "#{param_name} severity"].join("\n"))
+    d = create_driver([ipv4_config, "#{param_name} severity"].join("\n"))
     tests = create_test_case
 
     severity = 'info'
     d.run(expect_emits: 2) do
       u = UDPSocket.new
-      u.connect('127.0.0.1', PORT)
+      u.connect('127.0.0.1', @port)
       tests.each {|test|
         u.send(test['msg'], 0)
       }
@@ -254,13 +264,13 @@ EOS
   end
 
   def test_msg_size_with_facility_key
-    d = create_driver([CONFIG, 'facility_key facility'].join("\n"))
+    d = create_driver([ipv4_config, 'facility_key facility'].join("\n"))
     tests = create_test_case
 
     facility = 'kern'
     d.run(expect_emits: 2) do
       u = UDPSocket.new
-      u.connect('127.0.0.1', PORT)
+      u.connect('127.0.0.1', @port)
       tests.each {|test|
         u.send(test['msg'], 0)
       }
@@ -271,13 +281,13 @@ EOS
   end
 
   def test_msg_size_with_source_address_key
-    d = create_driver([CONFIG, 'source_address_key source_address'].join("\n"))
+    d = create_driver([ipv4_config, 'source_address_key source_address'].join("\n"))
     tests = create_test_case
 
     address = nil
     d.run(expect_emits: 2) do
       u = UDPSocket.new
-      u.connect('127.0.0.1', PORT)
+      u.connect('127.0.0.1', @port)
       address = u.peeraddr[3]
       tests.each {|test|
         u.send(test['msg'], 0)
@@ -289,14 +299,14 @@ EOS
   end
 
   def test_msg_size_with_source_hostname_key
-    d = create_driver([CONFIG, 'source_hostname_key source_hostname'].join("\n"))
+    d = create_driver([ipv4_config, 'source_hostname_key source_hostname'].join("\n"))
     tests = create_test_case
 
     hostname = nil
     d.run(expect_emits: 2) do
       u = UDPSocket.new
       u.do_not_reverse_lookup = false
-      u.connect('127.0.0.1', PORT)
+      u.connect('127.0.0.1', @port)
       hostname = u.peeraddr[2]
       tests.each {|test|
         u.send(test['msg'], 0)
@@ -337,12 +347,12 @@ EOS
 
   sub_test_case 'octet counting frame' do
     def test_msg_size_with_tcp
-      d = create_driver([CONFIG, "<transport tcp> \n</transport>", 'frame_type octet_count'].join("\n"))
+      d = create_driver([ipv4_config, "<transport tcp> \n</transport>", 'frame_type octet_count'].join("\n"))
       tests = create_test_case
 
       d.run(expect_emits: 2) do
         tests.each {|test|
-          TCPSocket.open('127.0.0.1', PORT) do |s|
+          TCPSocket.open('127.0.0.1', @port) do |s|
             s.send(test['msg'], 0)
           end
         }
@@ -353,11 +363,11 @@ EOS
     end
 
     def test_msg_size_with_same_tcp_connection
-      d = create_driver([CONFIG, "<transport tcp> \n</transport>", 'frame_type octet_count'].join("\n"))
+      d = create_driver([ipv4_config, "<transport tcp> \n</transport>", 'frame_type octet_count'].join("\n"))
       tests = create_test_case
 
       d.run(expect_emits: 2) do
-        TCPSocket.open('127.0.0.1', PORT) do |s|
+        TCPSocket.open('127.0.0.1', @port) do |s|
           tests.each {|test|
             s.send(test['msg'], 0)
           }
@@ -404,13 +414,13 @@ EOS
   end
 
   def test_emit_unmatched_lines
-    d = create_driver([CONFIG, 'emit_unmatched_lines true'].join("\n"))
+    d = create_driver([ipv4_config, 'emit_unmatched_lines true'].join("\n"))
     tests = create_unmatched_lines_test_case
 
     d.run(expect_emits: 3) do
       u = UDPSocket.new
       u.do_not_reverse_lookup = false
-      u.connect('127.0.0.1', PORT)
+      u.connect('127.0.0.1', @port)
       tests.each {|test|
         u.send(test['msg'], 0)
       }
@@ -421,14 +431,14 @@ EOS
   end
 
   def test_emit_unmatched_lines_with_hostname
-    d = create_driver([CONFIG, 'emit_unmatched_lines true', 'source_hostname_key source_hostname'].join("\n"))
+    d = create_driver([ipv4_config, 'emit_unmatched_lines true', 'source_hostname_key source_hostname'].join("\n"))
     tests = create_unmatched_lines_test_case
 
     hostname = nil
     d.run(expect_emits: 3) do
       u = UDPSocket.new
       u.do_not_reverse_lookup = false
-      u.connect('127.0.0.1', PORT)
+      u.connect('127.0.0.1', @port)
       hostname = u.peeraddr[2]
       tests.each {|test|
         u.send(test['msg'], 0)
@@ -440,14 +450,14 @@ EOS
   end
 
   def test_emit_unmatched_lines_with_address
-    d = create_driver([CONFIG, 'emit_unmatched_lines true', 'source_address_key source_address'].join("\n"))
+    d = create_driver([ipv4_config, 'emit_unmatched_lines true', 'source_address_key source_address'].join("\n"))
     tests = create_unmatched_lines_test_case
 
     address = nil
     d.run(expect_emits: 3) do
       u = UDPSocket.new
       u.do_not_reverse_lookup = false
-      u.connect('127.0.0.1', PORT)
+      u.connect('127.0.0.1', @port)
       address = u.peeraddr[3]
       tests.each {|test|
         u.send(test['msg'], 0)
@@ -457,4 +467,39 @@ EOS
     assert_equal tests.size, d.events.size
     compare_unmatched_lines_test_result(d.events, tests, {address: address})
   end
+
+  def test_send_keepalive_packet_is_disabled_by_default
+    d = create_driver(ipv4_config + %[
+      <transport tcp>
+      </transport>
+      protocol tcp
+    ])
+    assert_false d.instance.send_keepalive_packet
+  end
+
+  def test_send_keepalive_packet_can_be_enabled
+    addr = "127.0.0.1"
+    d = create_driver(ipv4_config + %[
+      <transport tcp>
+      </transport>
+      send_keepalive_packet true
+    ])
+    assert_true d.instance.send_keepalive_packet
+    mock.proxy(d.instance).server_create_connection(
+      :in_syslog_tcp_server, @port,
+      bind: addr,
+      resolve_name: nil,
+      send_keepalive_packet: true)
+    d.run do
+      TCPSocket.open(addr, @port)
+    end
+  end
+
+  def test_send_keepalive_packet_can_not_be_enabled_for_udp
+    assert_raise(Fluent::ConfigError) do
+      d = create_driver(ipv4_config + %[
+        send_keepalive_packet true
+      ])
+    end
+  end
 end

data/test/plugin/test_in_tail.rb

@@ -109,6 +109,7 @@ class TailInputTest < Test::Unit::TestCase
                                                 "refresh_interval" => "1s",
                                                 "read_from_head" => "true",
                                                 "format" => "none",
+                                                "rotate_wait" => "1s",
                                                 "follow_inodes" => "true"
                                               })
   SINGLE_LINE_CONFIG = config_element("", "", { "format" => "/(?<message>.*)/" })
@@ -346,23 +347,15 @@ class TailInputTest < Test::Unit::TestCase
       end
 
       sub_test_case "reads_bytes_per_second w/o throttled" do
-        data("flat 8192 bytes, 2 events"        => [:flat, 100, 8192, 2, false],
-             "flat 8192 bytes, 2 events already read limit reached" => [:flat, 100, 8192, 2, true],
-             "flat 8192 bytes, 2 events w/o stat watcher" => [:flat_without_stat, 100, 8192, 2, false],
+        data("flat 8192 bytes, 2 events"        => [:flat, 100, 8192, 2],
+             "flat 8192 bytes, 2 events w/o stat watcher" => [:flat_without_stat, 100, 8192, 2],
              "flat #{8192*10} bytes, 20 events"  => [:flat, 100, (8192 * 10), 20],
              "flat #{8192*10} bytes, 20 events w/o stat watcher"  => [:flat_without_stat, 100, (8192 * 10), 20],
              "parse #{8192*4} bytes, 8 events"  => [:parse, 100, (8192 * 4), 8],
              "parse #{8192*4} bytes, 8 events w/o stat watcher"  => [:parse_without_stat, 100, (8192 * 4), 8],
              "parse #{8192*10} bytes, 20 events" => [:parse, 100, (8192 * 10), 20],
              "parse #{8192*10} bytes, 20 events w/o stat watcher" => [:parse_without_stat, 100, (8192 * 10), 20],
-             "flat 8k bytes with unit, 2 events"        => [:flat, 100, "8k", 2],
-             "flat 8k bytes with unit, 2 events w/o stat watcher"        => [:flat_without_stat, 100, "8k", 2],
-             "flat #{8*10}k bytes with unit, 20 events"  => [:flat, 100, "#{8*10}k", 20],
-             "flat #{8*10}k bytes with unit, 20 events w/o stat watcher"  => [:flat_without_stat, 100, "#{8*10}k", 20],
-             "parse #{8*4}k bytes with unit, 8 events"  => [:parse, 100, "#{8*4}k", 8],
-             "parse #{8*4}k bytes with unit, 8 events w/o stat watcher"  => [:parse_without_stat, 100, "#{8*4}k", 8],
-             "parse #{8*10}k bytes with unit, 20 events" => [:parse, 100, "#{8*10}k", 20],
-             "parse #{8*10}k bytes with unit, 20 events w/o stat watcher" => [:parse_without_stat, 100, "#{8*10}k", 20])
+             "flat 8k bytes with unit, 2 events" => [:flat, 100, "8k", 2])
         def test_emit_with_read_bytes_limit_per_second(data)
           config_style, limit, limit_bytes, num_events = data
           case config_style
@@ -418,16 +411,10 @@ class TailInputTest < Test::Unit::TestCase
       end
 
       sub_test_case "reads_bytes_per_second w/ throttled already" do
-        data("flat 8192 bytes, 2 events"        => [:flat, 100, 8192, 2],
-             "flat #{8192*10} bytes, 20 events"  => [:flat, 100, (8192 * 10), 20],
-             "parse #{8192*4} bytes, 8 events"  => [:parse, 100, (8192 * 4), 8],
-             "parse #{8192*10} bytes, 20 events" => [:parse, 100, (8192 * 10), 20],
-             "flat 8k bytes with unit, 2 events"        => [:flat, 100, "8k", 2],
-             "flat #{8*10}k bytes with unit, 20 events"  => [:flat, 100, "#{8*10}k", 20],
-             "parse #{8*4}k bytes with unit, 8 events"  => [:parse, 100, "#{8*4}k", 8],
-             "parse #{8*10}k bytes with unit, 20 events" => [:parse, 100, "#{8*10}k", 20])
+        data("flat 8192 bytes"  => [:flat, 100, 8192],
+             "parse 8192 bytes" => [:parse, 100, 8192])
         def test_emit_with_read_bytes_limit_per_second(data)
-          config_style, limit, limit_bytes, num_events = data
+          config_style, limit, limit_bytes = data
           case config_style
           when :flat
             config = CONFIG_READ_FROM_HEAD + SINGLE_LINE_CONFIG + config_element("", "", { "read_lines_limit" => limit, "read_bytes_limit_per_second" => limit_bytes })
@@ -470,6 +457,91 @@ class TailInputTest < Test::Unit::TestCase
           assert_equal([], d.events)
         end
       end
+
+      sub_test_case "EOF with reads_bytes_per_second" do
+        def test_longer_than_rotate_wait
+          limit_bytes = 8192
+          num_lines = 1024 * 3
+          msg = "08bytes"
+
+          File.open("#{TMP_DIR}/tail.txt", "wb") do |f|
+            f.write("#{msg}\n" * num_lines)
+          end
+
+          config = CONFIG_READ_FROM_HEAD +
+                   SINGLE_LINE_CONFIG +
+                   config_element("", "", {
+                                    "read_bytes_limit_per_second" => limit_bytes,
+                                    "rotate_wait" => 0.1,
+                                    "refresh_interval" => 0.5,
+                                  })
+
+          rotated = false
+          d = create_driver(config)
+          d.run(timeout: 10) do
+            while d.events.size < num_lines do
+              if d.events.size > 0 && !rotated
+                cleanup_file("#{TMP_DIR}/tail.txt")
+                FileUtils.touch("#{TMP_DIR}/tail.txt")
+                rotated = true
+              end
+              sleep 0.3
+            end
+          end
+
+          assert_equal(num_lines,
+                       d.events.count do |event|
+                         event[2]["message"] == msg
+                       end)
+        end
+
+        def test_shorter_than_rotate_wait
+          limit_bytes = 8192
+          num_lines = 1024 * 2
+          msg = "08bytes"
+
+          File.open("#{TMP_DIR}/tail.txt", "wb") do |f|
+            f.write("#{msg}\n" * num_lines)
+          end
+
+          config = CONFIG_READ_FROM_HEAD +
+                   SINGLE_LINE_CONFIG +
+                   config_element("", "", {
+                                    "read_bytes_limit_per_second" => limit_bytes,
+                                    "rotate_wait" => 2,
+                                    "refresh_interval" => 0.5,
+                                  })
+
+          start_time = Fluent::Clock.now
+          rotated = false
+          detached = false
+          d = create_driver(config)
+          mock.proxy(d.instance).setup_watcher(anything, anything) do |tw|
+            mock.proxy(tw).detach(anything) do |v|
+              detached = true
+              v
+            end
+            tw
+          end.twice
+
+          d.run(timeout: 10) do
+            until detached do
+              if d.events.size > 0 && !rotated
+                cleanup_file("#{TMP_DIR}/tail.txt")
+                FileUtils.touch("#{TMP_DIR}/tail.txt")
+                rotated = true
+              end
+              sleep 0.3
+            end
+          end
+
+          assert_true(Fluent::Clock.now - start_time > 2)
+          assert_equal(num_lines,
+                       d.events.count do |event|
+                         event[2]["message"] == msg
+                       end)
+        end
+      end
     end
 
     data(flat: CONFIG_READ_FROM_HEAD + SINGLE_LINE_CONFIG,
@@ -1667,7 +1739,7 @@ class TailInputTest < Test::Unit::TestCase
       d.instance_shutdown
     end
 
-    def test_should_keep_and_update_existing_file_pos_entry_for_deleted_file_when_new_file_with_same_name_created
+    def test_should_remove_deleted_file
       config = config_element("", "", {"format" => "none"})
 
       path = "#{TMP_DIR}/tail.txt"
@@ -1678,30 +1750,11 @@ class TailInputTest < Test::Unit::TestCase
       }
 
       d = create_driver(config)
-      d.run(shutdown: false)
-
-      pos_file = File.open("#{TMP_DIR}/tail.pos", "r")
-      pos_file.pos = 0
-
-      path_pos_ino = /^([^\t]+)\t([0-9a-fA-F]+)\t([0-9a-fA-F]+)/.match(pos_file.readline)
-      assert_equal(path, path_pos_ino[1])
-      assert_equal(pos, path_pos_ino[2].to_i(16))
-      assert_equal(ino, path_pos_ino[3].to_i(16))
-
-      File.open("#{TMP_DIR}/tail.txt", "wb") {|f|
-        f.puts "test1"
-        f.puts "test2"
-      }
-      Timecop.travel(Time.now + 10) do
-        sleep 5
+      d.run do
+        pos_file = File.open("#{TMP_DIR}/tail.pos", "r")
         pos_file.pos = 0
-        tuple = create_target_info("#{TMP_DIR}/tail.txt")
-        path_pos_ino = /^([^\t]+)\t([0-9a-fA-F]+)\t([0-9a-fA-F]+)/.match(pos_file.readline)
-        assert_equal(tuple.path, path_pos_ino[1])
-        assert_equal(12, path_pos_ino[2].to_i(16))
-        assert_equal(tuple.ino, path_pos_ino[3].to_i(16))
+        assert_equal([], pos_file.readlines)
       end
-      d.instance_shutdown
     end
 
     def test_should_mark_file_unwatched_after_limit_recently_modified_and_rotate_wait
@@ -1913,6 +1966,49 @@ class TailInputTest < Test::Unit::TestCase
       assert_equal({"message" => "test4"}, events[3][2])
       d.instance_shutdown
     end
+
+    # issue #3464
+    def test_should_replace_target_info
+      File.open("#{TMP_DIR}/tail.txt", "wb") {|f|
+        f.puts "test1\n"
+      }
+      target_info = create_target_info("#{TMP_DIR}/tail.txt")
+      inodes = []
+
+      config = config_element("ROOT", "", {
+                                "path" => "#{TMP_DIR}/tail.txt*",
+                                "pos_file" => "#{TMP_DIR}/tail.pos",
+                                "tag" => "t1",
+                                "refresh_interval" => "60s",
+                                "read_from_head" => "true",
+                                "format" => "none",
+                                "rotate_wait" => "1s",
+                                "follow_inodes" => "true"
+                              })
+      d = create_driver(config, false)
+      d.run(timeout: 5) do
+        while d.events.size < 1 do
+          sleep 0.1
+        end
+        inodes = d.instance.instance_variable_get(:@tails).keys.collect do |key|
+          key.ino
+        end
+        assert_equal([target_info.ino], inodes)
+
+        cleanup_file("#{TMP_DIR}/tail.txt")
+        File.open("#{TMP_DIR}/tail.txt", "wb") {|f| f.puts "test2\n"}
+
+        while d.events.size < 2 do
+          sleep 0.1
+        end
+        inodes = d.instance.instance_variable_get(:@tails).keys.collect do |key|
+          key.ino
+        end
+        new_target_info = create_target_info("#{TMP_DIR}/tail.txt")
+        assert_not_equal(target_info.ino, new_target_info.ino)
+        assert_equal([new_target_info.ino], inodes)
+      end
+    end
   end
 
   sub_test_case "tail_path" do
@@ -2083,11 +2179,13 @@ class TailInputTest < Test::Unit::TestCase
     assert_nothing_raised do
       d.run(shutdown: false) {}
     end
-    d.instance_shutdown
     assert($log.out.logs.any?{|log| log.include?("stat() for #{path} failed with Errno::ENOENT. Drop tail watcher for now.\n") })
+  ensure
+    d.instance_shutdown if d && d.instance
   end
 
   def test_EACCES_error_after_setup_watcher
+    omit "Cannot test with root user" if Process::UID.eid == 0
     path = "#{TMP_DIR}/noaccess/tail.txt"
     begin
       FileUtils.mkdir_p("#{TMP_DIR}/noaccess")
@@ -2106,12 +2204,14 @@ class TailInputTest < Test::Unit::TestCase
       assert_nothing_raised do
         d.run(shutdown: false) {}
       end
-      d.instance_shutdown
       assert($log.out.logs.any?{|log| log.include?("stat() for #{path} failed with Errno::EACCES. Drop tail watcher for now.\n") })
     end
   ensure
-    FileUtils.chmod(0755, "#{TMP_DIR}/noaccess")
-    FileUtils.rm_rf("#{TMP_DIR}/noaccess")
+    d.instance_shutdown if d && d.instance
+    if File.exist?("#{TMP_DIR}/noaccess")
+      FileUtils.chmod(0755, "#{TMP_DIR}/noaccess")
+      FileUtils.rm_rf("#{TMP_DIR}/noaccess")
+    end
   end unless Fluent.windows?
 
   def test_EACCES
@@ -2127,8 +2227,9 @@ class TailInputTest < Test::Unit::TestCase
     assert_nothing_raised do
       d.run(shutdown: false) {}
     end
-    d.instance_shutdown
     assert($log.out.logs.any?{|log| log.include?("expand_paths: stat() for #{path} failed with Errno::EACCES. Skip file.\n") })
+  ensure
+    d.instance_shutdown if d && d.instance
   end
 
   def test_shutdown_timeout