logstash-input-file 4.1.3 → 4.1.4

data/lib/logstash/inputs/file.rb

@@ -206,7 +206,7 @@ class File < LogStash::Inputs::Base
   # 1MB from each active file. See the option `max_open_files` for more info.
   # The default set internally is very large, 4611686018427387903. By default
   # the file is read to the end before moving to the next active file.
-  config :file_chunk_count, :validate => :number, :default => FileWatch::FIXNUM_MAX
+  config :file_chunk_count, :validate => :number, :default => FileWatch::MAX_ITERATIONS
 
   # Which attribute of a discovered file should be used to sort the discovered files.
   # Files can be sort by modified date or full path alphabetic.
@@ -312,8 +312,14 @@ class File < LogStash::Inputs::Base
       end
     end
     @codec = LogStash::Codecs::IdentityMapCodec.new(@codec)
+    @completely_stopped = Concurrent::AtomicBoolean.new
   end # def register
 
+  def completely_stopped?
+    # to synchronise after(:each) blocks in tests that remove the sincedb file before atomic_write completes
+    @completely_stopped.true?
+  end
+
   def listener_for(path)
     # path is the identity
     FileListener.new(path, self)
@@ -333,6 +339,7 @@ class File < LogStash::Inputs::Base
     @watcher.subscribe(self) # halts here until quit is called
     # last action of the subscribe call is to write the sincedb
     exit_flush
+    @completely_stopped.make_true
   end # def run
 
   def post_process_this(event)
@@ -354,7 +361,7 @@ class File < LogStash::Inputs::Base
   end
 
   def stop
-    if @watcher
+    unless @watcher.nil?
       @codec.close
       @watcher.quit
     end

data/logstash-input-file.gemspec

@@ -1,7 +1,7 @@
 Gem::Specification.new do |s|
 
   s.name            = 'logstash-input-file'
-  s.version         = '4.1.3'
+  s.version         = '4.1.4'
   s.licenses        = ['Apache-2.0']
   s.summary         = "Streams events from files"
   s.description     = "This gem is a Logstash plugin required to be installed on top of the Logstash core pipeline using $LS_HOME/bin/logstash-plugin install gemname. This gem is not a stand-alone program"
@@ -23,7 +23,14 @@ Gem::Specification.new do |s|
   s.add_runtime_dependency "logstash-core-plugin-api", ">= 1.60", "<= 2.99"
 
   s.add_runtime_dependency 'logstash-codec-plain'
-  s.add_runtime_dependency 'addressable'
+
+  if RUBY_VERSION.start_with?("1")
+    s.add_runtime_dependency 'rake', '~> 12.2.0'
+    s.add_runtime_dependency 'addressable', '~> 2.4.0'
+  else
+    s.add_runtime_dependency 'addressable'
+  end
+
   s.add_runtime_dependency 'logstash-codec-multiline', ['~> 3.0']
 
   s.add_development_dependency 'stud', ['~> 0.0.19']

data/spec/file_ext/file_ext_windows_spec.rb

@@ -0,0 +1,36 @@
+# encoding: utf-8
+
+require_relative '../filewatch/spec_helper'
+
+if LogStash::Environment.windows?
+  describe "basic ops" do
+    let(:fixture_dir) { Pathname.new(FileWatch::FIXTURE_DIR).expand_path }
+    let(:file_path) { fixture_dir.join('uncompressed.log') }
+    it "path works" do
+      path = file_path.to_path
+      identifier = Winhelper.identifier_from_path(path)
+      STDOUT.puts("--- >>", identifier, "------")
+      expect(identifier.count('-')).to eq(2)
+      fs_name = Winhelper.file_system_type_from_path(path)
+      STDOUT.puts("--- >>", fs_name, "------")
+      expect(fs_name).to eq("NTFS")
+      # identifier = Winhelper.identifier_from_path_ex(path)
+      # STDOUT.puts("--- >>", identifier, "------")
+      # expect(identifier.count('-')).to eq(2)
+    end
+
+    it "io works" do
+      file = FileWatch::FileOpener.open(file_path.to_path)
+      identifier = Winhelper.identifier_from_io(file)
+      file.close
+      STDOUT.puts("--- >>", identifier, "------")
+      expect(identifier.count('-')).to eq(2)
+      # fs_name = Winhelper.file_system_type_from_io(file)
+      # STDOUT.puts("--- >>", fs_name, "------")
+      # expect(fs_name).to eq("NTFS")
+      # identifier = Winhelper.identifier_from_path_ex(path)
+      # STDOUT.puts("--- >>", identifier, "------")
+      # expect(identifier.count('-')).to eq(2)
+    end
+  end
+end

data/spec/filewatch/read_mode_handlers_read_file_spec.rb

@@ -12,7 +12,7 @@ module FileWatch
     let(:sdb_collection) { SincedbCollection.new(settings) }
     let(:directory) { Pathname.new(FIXTURE_DIR) }
     let(:pathname) { directory.join('uncompressed.log') }
-    let(:watched_file) { WatchedFile.new(pathname, pathname.stat, settings) }
+    let(:watched_file) { WatchedFile.new(pathname, PathStatClass.new(pathname), settings) }
     let(:processor) { ReadMode::Processor.new(settings).add_watch(watch) }
     let(:file) { DummyFileReader.new(settings.file_chunk_size, 2) }
 
@@ -20,7 +20,7 @@ module FileWatch
       let(:watch) { double("watch", :quit? => false) }
       it "calls 'sincedb_write' exactly 2 times" do
         allow(FileOpener).to receive(:open).with(watched_file.path).and_return(file)
-        expect(sdb_collection).to receive(:sincedb_write).exactly(2).times
+        expect(sdb_collection).to receive(:sincedb_write).exactly(1).times
         watched_file.activate
         processor.initialize_handlers(sdb_collection, TestObserver.new)
         processor.read_file(watched_file)

data/spec/filewatch/reading_spec.rb

@@ -30,82 +30,115 @@ module FileWatch
     end
     let(:observer) { TestObserver.new }
     let(:reading) { ObservingRead.new(opts) }
-    let(:actions) do
-      RSpec::Sequencing.run_after(0.45, "quit after a short time") do
-        reading.quit
-      end
-    end
+    let(:listener1) { observer.listener_for(file_path) }
 
     after do
       FileUtils.rm_rf(directory) unless directory =~ /fixture/
     end
 
     context "when watching a directory with files" do
-      let(:directory) { Stud::Temporary.directory }
-      let(:watch_dir) { ::File.join(directory, "*.log") }
-      let(:file_path) { ::File.join(directory, "1.log") }
-
+      let(:actions) do
+        RSpec::Sequencing.run("quit after a short time") do
+          File.open(file_path, "wb") { |file|  file.write("line1\nline2\n") }
+        end
+        .then("watch") do
+          reading.watch_this(watch_dir)
+        end
+        .then("wait") do
+          wait(2).for{listener1.calls.last}.to eq(:delete)
+        end
+        .then("quit") do
+          reading.quit
+        end
+      end
       it "the file is read" do
-        File.open(file_path, "wb") { |file|  file.write("line1\nline2\n") }
-        actions.activate
-        reading.watch_this(watch_dir)
+        actions.activate_quietly
         reading.subscribe(observer)
-        expect(observer.listener_for(file_path).calls).to eq([:open, :accept, :accept, :eof, :delete])
-        expect(observer.listener_for(file_path).lines).to eq(["line1", "line2"])
+        actions.assert_no_errors
+        expect(listener1.calls).to eq([:open, :accept, :accept, :eof, :delete])
+        expect(listener1.lines).to eq(["line1", "line2"])
       end
     end
 
     context "when watching a directory with files and sincedb_path is /dev/null or NUL" do
-      let(:directory) { Stud::Temporary.directory }
       let(:sincedb_path) { File::NULL }
-      let(:watch_dir) { ::File.join(directory, "*.log") }
-      let(:file_path) { ::File.join(directory, "1.log") }
-
+      let(:actions) do
+        RSpec::Sequencing.run("quit after a short time") do
+          File.open(file_path, "wb") { |file|  file.write("line1\nline2\n") }
+        end
+        .then("watch") do
+          reading.watch_this(watch_dir)
+        end
+        .then("wait") do
+          wait(2).for{listener1.calls.last}.to eq(:delete)
+        end
+        .then("quit") do
+          reading.quit
+        end
+      end
       it "the file is read" do
-        File.open(file_path, "wb") { |file|  file.write("line1\nline2\n") }
-        actions.activate
-        reading.watch_this(watch_dir)
+        actions.activate_quietly
         reading.subscribe(observer)
-        expect(observer.listener_for(file_path).calls).to eq([:open, :accept, :accept, :eof, :delete])
-        expect(observer.listener_for(file_path).lines).to eq(["line1", "line2"])
+        actions.assert_no_errors
+        expect(listener1.calls).to eq([:open, :accept, :accept, :eof, :delete])
+        expect(listener1.lines).to eq(["line1", "line2"])
       end
     end
 
     context "when watching a directory with files using striped reading" do
-      let(:directory) { Stud::Temporary.directory }
-      let(:watch_dir) { ::File.join(directory, "*.log") }
-      let(:file_path1) { ::File.join(directory, "1.log") }
       let(:file_path2) { ::File.join(directory, "2.log") }
       # use a chunk size that does not align with the line boundaries
-      let(:opts) { super.merge(:file_chunk_size => 10, :file_chunk_count => 1)}
+      let(:opts) { super.merge(:file_chunk_size => 10, :file_chunk_count => 1, :file_sort_by => "path")}
       let(:lines) { [] }
       let(:observer) { TestObserver.new(lines) }
-
+      let(:listener2) { observer.listener_for(file_path2) }
+      let(:actions) do
+        RSpec::Sequencing.run("create file") do
+          File.open(file_path,  "w") { |file|  file.write("string1\nstring2") }
+          File.open(file_path2, "w") { |file|  file.write("stringA\nstringB") }
+        end
+        .then("watch") do
+          reading.watch_this(watch_dir)
+        end
+        .then("wait") do
+          wait(2).for{listener1.calls.last == :delete && listener2.calls.last == :delete}.to eq(true)
+        end
+        .then("quit") do
+          reading.quit
+        end
+      end
       it "the files are read seemingly in parallel" do
-        File.open(file_path1, "w") { |file|  file.write("string1\nstring2\n") }
-        File.open(file_path2, "w") { |file|  file.write("stringA\nstringB\n") }
-        actions.activate
-        reading.watch_this(watch_dir)
+        actions.activate_quietly
         reading.subscribe(observer)
-        if lines.first == "stringA"
-          expect(lines).to eq(%w(stringA string1 stringB string2))
-        else
-          expect(lines).to eq(%w(string1 stringA string2 stringB))
-        end
+        actions.assert_no_errors
+        expect(listener1.calls).to eq([:open, :accept, :accept, :eof, :delete])
+        expect(listener2.calls).to eq([:open, :accept, :accept, :eof, :delete])
+        expect(lines).to eq(%w(string1 stringA string2 stringB))
       end
     end
 
     context "when a non default delimiter is specified and it is not in the content" do
       let(:opts) { super.merge(:delimiter => "\nø") }
-
+      let(:actions) do
+        RSpec::Sequencing.run("create file") do
+          File.open(file_path, "wb") { |file|  file.write("line1\nline2") }
+        end
+        .then("watch") do
+          reading.watch_this(watch_dir)
+        end
+        .then("wait") do
+          wait(2).for{listener1.calls.last}.to eq(:delete)
+        end
+        .then("quit") do
+          reading.quit
+        end
+      end
       it "the file is opened, data is read, but no lines are found initially, at EOF the whole file becomes the line" do
-        File.open(file_path, "wb") { |file|  file.write("line1\nline2") }
-        actions.activate
-        reading.watch_this(watch_dir)
+        actions.activate_quietly
         reading.subscribe(observer)
-        listener = observer.listener_for(file_path)
-        expect(listener.calls).to eq([:open, :accept, :eof, :delete])
-        expect(listener.lines).to eq(["line1\nline2"])
+        actions.assert_no_errors
+        expect(listener1.calls).to eq([:open, :accept, :eof, :delete])
+        expect(listener1.lines).to eq(["line1\nline2"])
         sincedb_record_fields = File.read(sincedb_path).split(" ")
         position_field_index = 3
         # tailing, no delimiter, we are expecting one, if it grows we read from the start.
@@ -116,18 +149,28 @@ module FileWatch
 
     describe "reading fixtures" do
       let(:directory) { FIXTURE_DIR }
-
+      let(:actions) do
+        RSpec::Sequencing.run("watch") do
+          reading.watch_this(watch_dir)
+        end
+        .then("wait") do
+          wait(1).for{listener1.calls.last}.to eq(:delete)
+        end
+        .then("quit") do
+          reading.quit
+        end
+      end
       context "for an uncompressed file" do
         let(:watch_dir) { ::File.join(directory, "unc*.log") }
         let(:file_path) { ::File.join(directory, 'uncompressed.log') }
 
         it "the file is read" do
           FileWatch.make_fixture_current(file_path)
-          actions.activate
-          reading.watch_this(watch_dir)
+          actions.activate_quietly
           reading.subscribe(observer)
-          expect(observer.listener_for(file_path).calls).to eq([:open, :accept, :accept, :eof, :delete])
-          expect(observer.listener_for(file_path).lines.size).to eq(2)
+          actions.assert_no_errors
+          expect(listener1.calls).to eq([:open, :accept, :accept, :eof, :delete])
+          expect(listener1.lines.size).to eq(2)
         end
       end
 
@@ -137,11 +180,11 @@ module FileWatch
 
         it "the file is read" do
           FileWatch.make_fixture_current(file_path)
-          actions.activate
-          reading.watch_this(watch_dir)
+          actions.activate_quietly
           reading.subscribe(observer)
-          expect(observer.listener_for(file_path).calls).to eq([:open, :accept, :accept, :eof, :delete])
-          expect(observer.listener_for(file_path).lines.size).to eq(2)
+          actions.assert_no_errors
+          expect(listener1.calls).to eq([:open, :accept, :accept, :eof, :delete])
+          expect(listener1.lines.size).to eq(2)
         end
       end
 
@@ -151,11 +194,11 @@ module FileWatch
 
         it "the file is read" do
           FileWatch.make_fixture_current(file_path)
-          actions.activate
-          reading.watch_this(watch_dir)
+          actions.activate_quietly
           reading.subscribe(observer)
-          expect(observer.listener_for(file_path).calls).to eq([:open, :accept, :accept, :eof, :delete])
-          expect(observer.listener_for(file_path).lines.size).to eq(2)
+          actions.assert_no_errors
+          expect(listener1.calls).to eq([:open, :accept, :accept, :eof, :delete])
+          expect(listener1.lines.size).to eq(2)
         end
       end
     end

data/spec/filewatch/rotate_spec.rb

@@ -0,0 +1,451 @@
+# encoding: utf-8
+require 'stud/temporary'
+require_relative 'spec_helper'
+require 'filewatch/observing_tail'
+
+# simulate size based rotation ala
+# See https://docs.python.org/2/library/logging.handlers.html#rotatingfilehandler
+# The specified file is opened and used as the stream for logging.
+# If mode is not specified, 'a' is used. If encoding is not None, it is used to
+# open the file with that encoding. If delay is true, then file opening is deferred
+# until the first call to emit(). By default, the file grows indefinitely.
+# You can use the maxBytes and backupCount values to allow the file to rollover
+# at a predetermined size. When the size is about to be exceeded, the file is
+# closed and a new file is silently opened for output. Rollover occurs whenever
+# the current log file is nearly maxBytes in length; if either of maxBytes or
+# backupCount is zero, rollover never occurs. If backupCount is non-zero, the
+# system will save old log files by appending the extensions ‘.1’, ‘.2’ etc.,
+# to the filename. For example, with a backupCount of 5 and a base file name of
+# app.log, you would get app.log, app.log.1, app.log.2, up to app.log.5.
+# The file being written to is always app.log. When this file is filled, it is
+# closed and renamed to app.log.1, and if files app.log.1, app.log.2, etc.
+# exist, then they are renamed to app.log.2, app.log.3 etc. respectively.
+
+module FileWatch
+  describe Watch, :unix => true do
+    let(:directory) { Pathname.new(Stud::Temporary.directory) }
+    let(:file1_path) { file_path.to_path }
+    let(:max)   { 4095 }
+    let(:stat_interval) { 0.01 }
+    let(:discover_interval) { 15 }
+    let(:start_new_files_at) { :beginning }
+    let(:sincedb_path) { directory.join("tailing.sdb") }
+    let(:opts) do
+      {
+        :stat_interval => stat_interval, :start_new_files_at => start_new_files_at, :max_open_files => max,
+        :delimiter => "\n", :discover_interval => discover_interval, :sincedb_path => sincedb_path.to_path
+      }
+    end
+    let(:observer) { TestObserver.new }
+    let(:tailing) { ObservingTail.new(opts) }
+    let(:line1) { "Line 1 - Lorem ipsum dolor sit amet, consectetur adipiscing elit." }
+    let(:line2) { "Line 2 - Proin ut orci lobortis, congue diam in, dictum est." }
+    let(:line3) { "Line 3 - Sed vestibulum accumsan sollicitudin." }
+
+    before do
+      directory
+      wait(1.0).for{Dir.exist?(directory)}.to eq(true)
+    end
+
+    after do
+      FileUtils.rm_rf(directory)
+      wait(1.0).for{Dir.exist?(directory)}.to eq(false)
+    end
+
+    context "create + rename rotation: when a new logfile is renamed to a path we have seen before and the open file is fully read, renamed outside glob" do
+      let(:watch_dir) { directory.join("*A.log") }
+      let(:file_path) { directory.join("1A.log") }
+      subject { described_class.new(conf) }
+      let(:listener1) { observer.listener_for(file1_path) }
+      let(:listener2) { observer.listener_for(second_file.to_path) }
+      let(:actions) do
+        RSpec::Sequencing
+          .run_after(0.25, "create file") do
+            file_path.open("wb") { |file|  file.write("#{line1}\n") }
+          end
+          .then_after(0.25, "write a 'unfinished' line") do
+            file_path.open("ab") { |file|  file.write(line2) }
+          end
+          .then_after(0.25, "rotate once") do
+            tmpfile = directory.join("1.logtmp")
+            tmpfile.open("wb") { |file|  file.write("\n#{line3}\n")}
+            file_path.rename(directory.join("1.log.1"))
+            FileUtils.mv(directory.join("1.logtmp").to_path, file1_path)
+          end
+          .then("wait for expectation") do
+            wait(2).for{listener1.calls}.to eq([:open, :accept, :accept, :accept])
+          end
+          .then("quit") do
+            tailing.quit
+          end
+      end
+
+      it "content from both inodes are sent via the same stream" do
+        actions.activate_quietly
+        tailing.watch_this(watch_dir.to_path)
+        tailing.subscribe(observer)
+        actions.assert_no_errors
+        lines = listener1.lines
+        expect(lines[0]).to eq(line1)
+        expect(lines[1]).to eq(line2)
+        expect(lines[2]).to eq(line3)
+      end
+    end
+
+    context "create + rename rotation: a multiple file rename cascade" do
+      let(:watch_dir) { directory.join("*B.log") }
+      let(:file_path) { directory.join("1B.log") }
+      subject { described_class.new(conf) }
+      let(:second_file) { directory.join("2B.log") }
+      let(:third_file) { directory.join("3B.log") }
+      let(:listener1) { observer.listener_for(file1_path) }
+      let(:listener2) { observer.listener_for(second_file.to_path) }
+      let(:listener3) { observer.listener_for(third_file.to_path) }
+      let(:actions) do
+        RSpec::Sequencing
+          .run_after(0.25, "create file") do
+            file_path.open("wb") { |file|  file.write("#{line1}\n") }
+          end
+          .then_after(0.25, "rotate 1 - line1(66) is in 2B.log, line2(61) is in 1B.log") do
+            file_path.rename(second_file)
+            file_path.open("wb") { |file|  file.write("#{line2}\n") }
+          end
+          .then_after(0.25, "rotate 2 - line1(66) is in 3B.log, line2(61) is in 2B.log, line3(47) is in 1B.log") do
+            second_file.rename(third_file)
+            file_path.rename(second_file)
+            file_path.open("wb") { |file|  file.write("#{line3}\n") }
+          end
+          .then("wait for expectations to be met") do
+            wait(0.75).for{listener1.lines.size == 3 && listener3.lines.empty? && listener2.lines.empty?}.to eq(true)
+          end
+          .then("quit") do
+            tailing.quit
+          end
+      end
+
+      it "content from both inodes are sent via the same stream" do
+        actions.activate_quietly
+        tailing.watch_this(watch_dir.to_path)
+        tailing.subscribe(observer)
+        actions.assert_no_errors
+        expect(listener1.lines[0]).to eq(line1)
+        expect(listener1.lines[1]).to eq(line2)
+        expect(listener1.lines[2]).to eq(line3)
+      end
+    end
+
+    context "create + rename rotation: a two file rename cascade in slow motion" do
+      let(:watch_dir) { directory.join("*C.log") }
+      let(:file_path) { directory.join("1C.log") }
+      let(:stat_interval) { 0.01 }
+      subject { described_class.new(conf) }
+      let(:second_file) { directory.join("2C.log") }
+      let(:listener1) { observer.listener_for(file1_path) }
+      let(:listener2) { observer.listener_for(second_file.to_path) }
+      let(:actions) do
+        RSpec::Sequencing
+          .run_after(0.25, "create original - write line 1, 66 bytes") do
+            file_path.open("wb") { |file|  file.write("#{line1}\n") }
+          end
+          .then_after(0.25, "rename to 2.log") do
+            file_path.rename(second_file)
+          end
+          .then_after(0.25, "write line 2 to original, 61 bytes") do
+            file_path.open("wb") { |file|  file.write("#{line2}\n") }
+          end
+          .then_after(0.25, "rename to 2.log again") do
+            file_path.rename(second_file)
+          end
+          .then_after(0.25, "write line 3 to original, 47 bytes") do
+            file_path.open("wb") { |file|  file.write("#{line3}\n") }
+          end
+          .then("wait for expectations to be met") do
+            wait(1).for{listener1.lines.size == 3 && listener2.lines.empty?}.to eq(true)
+          end
+          .then("quit") do
+            tailing.quit
+          end
+      end
+
+      it "content from both inodes are sent via the same stream AND content from the rotated file is not read again" do
+        actions.activate_quietly
+        tailing.watch_this(watch_dir.to_path)
+        tailing.subscribe(observer)
+        actions.assert_no_errors
+        expect(listener1.lines[0]).to eq(line1)
+        expect(listener1.lines[1]).to eq(line2)
+        expect(listener1.lines[2]).to eq(line3)
+      end
+    end
+
+    context "create + rename rotation: a two file rename cascade in normal speed" do
+      let(:watch_dir) { directory.join("*D.log") }
+      let(:file_path) { directory.join("1D.log") }
+      subject { described_class.new(conf) }
+      let(:second_file) { directory.join("2D.log") }
+      let(:listener1) { observer.listener_for(file1_path) }
+      let(:listener2) { observer.listener_for(second_file.to_path) }
+      let(:actions) do
+        RSpec::Sequencing
+          .run_after(0.25, "create original - write line 1, 66 bytes") do
+            file_path.open("wb") { |file|  file.write("#{line1}\n") }
+          end
+          .then_after(0.25, "rename to 2.log") do
+            file_path.rename(second_file)
+            file_path.open("wb") { |file|  file.write("#{line2}\n") }
+          end
+          .then_after(0.25, "rename to 2.log again") do
+            file_path.rename(second_file)
+            file_path.open("wb") { |file|  file.write("#{line3}\n") }
+          end
+          .then("wait for expectations to be met") do
+            wait(0.5).for{listener1.lines.size == 3 && listener2.lines.empty?}.to eq(true)
+          end
+          .then("quit") do
+            tailing.quit
+          end
+      end
+
+      it "content from both inodes are sent via the same stream AND content from the rotated file is not read again" do
+        actions.activate_quietly
+        tailing.watch_this(watch_dir.to_path)
+        tailing.subscribe(observer)
+        actions.assert_no_errors
+        expect(listener1.lines[0]).to eq(line1)
+        expect(listener1.lines[1]).to eq(line2)
+        expect(listener1.lines[2]).to eq(line3)
+      end
+    end
+
+    context "create + rename rotation: when a new logfile is renamed to a path we have seen before but not all content from the previous the file is read" do
+      let(:opts) { super.merge(
+          :file_chunk_size => line1.bytesize.succ,
+          :file_chunk_count => 1
+        ) }
+      let(:watch_dir) { directory.join("*E.log") }
+      let(:file_path) { directory.join("1E.log") }
+      subject { described_class.new(conf) }
+      let(:listener1) { observer.listener_for(file1_path) }
+      let(:actions) do
+        RSpec::Sequencing
+          .run_after(0.25, "create file") do
+            file_path.open("wb") do |file|
+              65.times{file.puts(line1)}
+            end
+          end
+          .then_after(0.25, "rotate") do
+            tmpfile = directory.join("1E.logtmp")
+            tmpfile.open("wb") { |file|  file.puts(line1)}
+            file_path.rename(directory.join("1E.log.1"))
+            tmpfile.rename(directory.join("1E.log"))
+          end
+          .then("wait for expectations to be met") do
+            wait(0.5).for{listener1.lines.size}.to eq(66)
+          end
+          .then("quit") do
+            tailing.quit
+          end
+      end
+
+      it "content from both inodes are sent via the same stream" do
+        actions.activate_quietly
+        tailing.watch_this(watch_dir.to_path)
+        tailing.subscribe(observer)
+        actions.assert_no_errors
+        expected_calls = ([:accept] * 66).unshift(:open)
+        expect(listener1.lines.uniq).to eq([line1])
+        expect(listener1.calls).to eq(expected_calls)
+        expect(sincedb_path.readlines.size).to eq(2)
+      end
+    end
+
+    context "copy + truncate rotation: when a logfile is copied to a new path and truncated and the open file is fully read" do
+      let(:watch_dir) { directory.join("*F.log") }
+      let(:file_path) { directory.join("1F.log") }
+      subject { described_class.new(conf) }
+      let(:listener1) { observer.listener_for(file1_path) }
+      let(:actions) do
+        RSpec::Sequencing
+          .run_after(0.25, "create file") do
+            file_path.open("wb") { |file|  file.puts(line1); file.puts(line2) }
+          end
+          .then_after(0.25, "rotate") do
+            FileUtils.cp(file1_path, directory.join("1F.log.1").to_path)
+            file_path.truncate(0)
+          end
+          .then_after(0.25, "write to truncated file") do
+            file_path.open("wb") { |file|  file.puts(line3) }
+          end
+          .then("wait for expectations to be met") do
+            wait(0.5).for{listener1.lines.size}.to eq(3)
+          end
+          .then("quit") do
+            tailing.quit
+          end
+      end
+
+      it "content is read correctly" do
+        actions.activate_quietly
+        tailing.watch_this(watch_dir.to_path)
+        tailing.subscribe(observer)
+        actions.assert_no_errors
+        expect(listener1.lines).to eq([line1, line2, line3])
+        expect(listener1.calls).to eq([:open, :accept, :accept, :accept])
+      end
+    end
+
+    context "copy + truncate rotation: when a logfile is copied to a new path and truncated before the open file is fully read" do
+      let(:opts) { super.merge(
+          :file_chunk_size => line1.bytesize.succ,
+          :file_chunk_count => 1
+        ) }
+      let(:watch_dir) { directory.join("*G.log") }
+      let(:file_path) { directory.join("1G.log") }
+      subject { described_class.new(conf) }
+      let(:listener1) { observer.listener_for(file1_path) }
+      let(:actions) do
+        RSpec::Sequencing
+          .run_after(0.25, "create file") do
+            file_path.open("wb") { |file|  65.times{file.puts(line1)} }
+          end
+          .then_after(0.25, "rotate") do
+            FileUtils.cp(file1_path, directory.join("1G.log.1").to_path)
+            file_path.truncate(0)
+          end
+          .then_after(0.25, "write to truncated file") do
+            file_path.open("wb") { |file|  file.puts(line3) }
+          end
+          .then("wait for expectations to be met") do
+            wait(0.5).for{listener1.lines.last}.to eq(line3)
+          end
+          .then("quit") do
+            tailing.quit
+          end
+      end
+
+      it "unread content before the truncate is lost" do
+        actions.activate_quietly
+        tailing.watch_this(watch_dir.to_path)
+        tailing.subscribe(observer)
+        actions.assert_no_errors
+        expect(listener1.lines.size).to be < 66
+      end
+    end
+
+    context "? rotation: when an active file is renamed inside the glob and the reading does not lag" do
+      let(:watch_dir) { directory.join("*H.log") }
+      let(:file_path) { directory.join("1H.log") }
+      let(:file2) { directory.join("2H.log") }
+      subject { described_class.new(conf) }
+      let(:listener1) { observer.listener_for(file1_path) }
+      let(:listener2) { observer.listener_for(file2.to_path) }
+      let(:actions) do
+        RSpec::Sequencing
+          .run_after(0.25, "create file") do
+            file_path.open("wb") { |file|  file.puts(line1); file.puts(line2) }
+          end
+          .then_after(0.25, "rename") do
+            FileUtils.mv(file1_path, file2.to_path)
+          end
+          .then_after(0.25, "write to renamed file") do
+            file2.open("ab") { |file|  file.puts(line3) }
+          end
+          .then("wait for expectations to be met") do
+            wait(0.75).for{listener1.lines.size + listener2.lines.size}.to eq(3)
+          end
+          .then("quit") do
+            tailing.quit
+          end
+      end
+
+      it "content is read correctly, the renamed file is not reread from scratch" do
+        actions.activate_quietly
+        tailing.watch_this(watch_dir.to_path)
+        tailing.subscribe(observer)
+        actions.assert_no_errors
+        expect(listener1.lines).to eq([line1, line2])
+        expect(listener2.lines).to eq([line3])
+      end
+    end
+
+    context "? rotation: when an active file is renamed inside the glob and the reading lags behind" do
+      let(:opts) { super.merge(
+          :file_chunk_size => line1.bytesize.succ,
+          :file_chunk_count => 2
+        ) }
+      let(:watch_dir) { directory.join("*I.log") }
+      let(:file_path) { directory.join("1I.log") }
+      let(:file2) { directory.join("2I.log") }
+      subject { described_class.new(conf) }
+      let(:listener1) { observer.listener_for(file1_path) }
+      let(:listener2) { observer.listener_for(file2.to_path) }
+      let(:actions) do
+        RSpec::Sequencing
+          .run_after(0.25, "create file") do
+            file_path.open("wb") { |file| 65.times{file.puts(line1)} }
+          end
+          .then_after(0.25, "rename") do
+            FileUtils.mv(file1_path, file2.to_path)
+          end
+          .then_after(0.25, "write to renamed file") do
+            file2.open("ab") { |file|  file.puts(line3) }
+          end
+          .then("wait for expectations to be met") do
+            wait(1.25).for{listener1.lines.size + listener2.lines.size}.to eq(66)
+          end
+          .then("quit") do
+            tailing.quit
+          end
+      end
+
+      it "content is read correctly, the renamed file is not reread from scratch" do
+        actions.activate_quietly
+        tailing.watch_this(watch_dir.to_path)
+        tailing.subscribe(observer)
+        actions.assert_no_errors
+        expect(listener2.lines.last).to eq(line3)
+      end
+    end
+
+    context "? rotation: when a not active file is rotated outside the glob before the file is read" do
+      let(:opts) { super.merge(
+          :close_older => 3600,
+          :max_open_files => 1,
+          :file_sort_by => "path"
+        ) }
+      let(:watch_dir) { directory.join("*J.log") }
+      let(:file_path) { directory.join("1J.log") }
+      let(:file2) { directory.join("2J.log") }
+      let(:file3) { directory.join("2J.log.1") }
+      let(:listener1) { observer.listener_for(file1_path) }
+      let(:listener2) { observer.listener_for(file2.to_path) }
+      let(:listener3) { observer.listener_for(file3.to_path) }
+      subject { described_class.new(conf) }
+      let(:actions) do
+        RSpec::Sequencing
+          .run_after(0.25, "create file") do
+            file_path.open("wb") { |file| 65.times{file.puts(line1)} }
+            file2.open("wb")     { |file| 65.times{file.puts(line1)} }
+          end
+          .then_after(0.25, "rename") do
+            FileUtils.mv(file2.to_path, file3.to_path)
+          end
+          .then("wait for expectations to be met") do
+            wait(1.25).for{listener1.lines.size}.to eq(65)
+          end
+          .then("quit") do
+            tailing.quit
+          end
+      end
+
+      it "file 1 content is read correctly, the renamed file 2 is not read at all" do
+        actions.activate_quietly
+        tailing.watch_this(watch_dir.to_path)
+        tailing.subscribe(observer)
+        actions.assert_no_errors
+        expect(listener2.lines.size).to eq(0)
+        expect(listener3.lines.size).to eq(0)
+      end
+    end
+  end
+end