fluentd 1.9.3 → 1.11.1

data/test/plugin/in_tail/test_position_file.rb

@@ -6,7 +6,7 @@ require 'tempfile'
 
 class IntailPositionFileTest < Test::Unit::TestCase
   setup do
-    @file = Tempfile.new('intail_position_file_test')
+    @file = Tempfile.new('intail_position_file_test').binmode
   end
 
   teardown do
@@ -77,6 +77,30 @@ class IntailPositionFileTest < Test::Unit::TestCase
       lines = @file.readlines
       assert_equal 5, lines.size
     end
+
+    test 'update seek postion of remained position entry' do
+      pf = Fluent::Plugin::TailInput::PositionFile.new(@file, logger: $log)
+      pf['path1']
+      pf['path2']
+      pf['path3']
+      pf.unwatch('path1')
+
+      pf.try_compact
+
+      @file.seek(0)
+      lines = @file.readlines
+      assert_equal "path2\t0000000000000000\t0000000000000000\n", lines[0]
+      assert_equal "path3\t0000000000000000\t0000000000000000\n", lines[1]
+      assert_equal 2, lines.size
+
+      pf.unwatch('path2')
+      pf.unwatch('path3')
+      @file.seek(0)
+      lines = @file.readlines
+      assert_equal "path2\t#{UNWATCHED_STR}\t0000000000000000\n", lines[0]
+      assert_equal "path3\t#{UNWATCHED_STR}\t0000000000000000\n", lines[1]
+      assert_equal 2, lines.size
+    end
   end
 
   sub_test_case '#load' do

data/test/plugin/out_forward/test_handshake_protocol.rb

@@ -81,6 +81,15 @@ class HandshakeProtocolTest < Test::Unit::TestCase
       assert_equal(ri.state, :established)
     end
 
+    test 'raises an error when password and username are nil if auth exists' do
+      handshake = Fluent::Plugin::ForwardOutput::HandshakeProtocol.new(log: $log, hostname: 'hostname', shared_key: 'shared_key', password: nil, username: nil)
+      ri = Fluent::Plugin::ForwardOutput::ConnectionManager::RequestInfo.new(:helo)
+
+      assert_raise(Fluent::Plugin::ForwardOutput::PingpongError.new('username and password are required')) do
+        handshake.invoke('', ri, ['HELO', { 'auth' => 'auth' }])
+      end
+    end
+
     data(
       lack_of_elem: ['PONG', true, '', 'client_hostname'],
       wrong_message: ['WRONG_PONG', true, '', 'client_hostname', '40a3c5943cc6256e0c5dcf176e97db3826b0909698c330dc8e53d15af63efb47e030d113130255dd6e7ced5176d2999cc2e02a44852d45152503af317b73b33f'],
@@ -89,7 +98,7 @@ class HandshakeProtocolTest < Test::Unit::TestCase
       wrong_key: ['PONG', true, '', 'hostname', 'wrong_key'],
     )
     test 'raises an error when message is' do |msg|
-      handshake = Fluent::Plugin::ForwardOutput::HandshakeProtocol.new(log: $log, hostname: 'hostname', shared_key: 'shared_key', password: nil, username: nil)
+      handshake = Fluent::Plugin::ForwardOutput::HandshakeProtocol.new(log: $log, hostname: 'hostname', shared_key: 'shared_key', password: '', username: '')
       handshake.instance_variable_set(:@shared_key_salt, 'ce1897b0d3dbd76b90d7fb96010dcac3') # to fix salt
 
       ri = Fluent::Plugin::ForwardOutput::ConnectionManager::RequestInfo.new(:pingpong, '', '')

data/test/plugin/out_forward/test_load_balancer.rb

@@ -49,6 +49,44 @@ class LoadBalancerTest < Test::Unit::TestCase
       end
     end
 
+    test 'call like round robin without weight=0 node' do
+      lb = Fluent::Plugin::ForwardOutput::LoadBalancer.new($log)
+      n1 = flexmock('node', :'standby?' => false, :'available?' => true, weight: 1)
+      n2 = flexmock('node', :'standby?' => false, :'available?' => true, weight: 1)
+      n3 = flexmock('node', :'standby?' => false, :'available?' => true, weight: 0)
+
+      lb.rebuild_weight_array([n1, n2, n3])
+
+      lb.select_healthy_node do |node|
+        # to handle random choice
+        if node == n1
+          lb.select_healthy_node do |node|
+            assert_equal(node, n2)
+          end
+
+          lb.select_healthy_node do |node|
+            assert_equal(node, n1)
+          end
+
+          lb.select_healthy_node do |node|
+            assert_equal(node, n2)
+          end
+        else
+          lb.select_healthy_node do |node|
+            assert_equal(node, n1)
+          end
+
+          lb.select_healthy_node do |node|
+            assert_equal(node, n2)
+          end
+
+          lb.select_healthy_node do |node|
+            assert_equal(node, n1)
+          end
+        end
+      end
+    end
+
     test 'raise an error if all node are unavialble' do
       lb = Fluent::Plugin::ForwardOutput::LoadBalancer.new($log)
       lb.rebuild_weight_array([flexmock('node', :'standby?' => false, :'available?' => false, weight: 1)])
@@ -56,5 +94,13 @@ class LoadBalancerTest < Test::Unit::TestCase
         lb.select_healthy_node
       end
     end
+
+    test 'it regards weight=0 node as unavialble' do
+      lb = Fluent::Plugin::ForwardOutput::LoadBalancer.new($log)
+      lb.rebuild_weight_array([flexmock('node', :'standby?' => false, :'available?' => true, weight: 0)])
+      assert_raise(Fluent::Plugin::ForwardOutput::NoNodesAvailable) do
+        lb.select_healthy_node
+      end
+    end
   end
 end

data/test/plugin/test_buf_file.rb

@@ -1062,7 +1062,9 @@ class FileBufferTest < Test::Unit::TestCase
       if @bufdir
         Dir.glob(File.join(@bufdir, '*')).each do |path|
           next if ['.', '..'].include?(File.basename(path))
-          File.delete(path)
+          # Windows does not permit to delete files which are used in another process.
+          # Just ignore for removing failure.
+          File.delete(path) rescue nil
         end
       end
     end

data/test/plugin/test_buffer.rb

@@ -1202,4 +1202,24 @@ class BufferTest < Test::Unit::TestCase
       assert chunk.singleton_class.ancestors.include?(Fluent::Plugin::Buffer::Chunk::Decompressable)
     end
   end
+
+  sub_test_case '#statistics' do
+    setup do
+      @p = create_buffer({ "total_limit_size" => 1024 })
+      dm = create_metadata(Time.parse('2020-03-13 16:00:00 +0000').to_i, nil, nil)
+
+      (class << @p; self; end).module_eval do
+        define_method(:resume) {
+          queued = [create_chunk(dm, ["a" * (1024 - 102)]).enqueued!]
+          return {}, queued
+        }
+      end
+
+      @p.start
+    end
+
+    test 'returns available_buffer_space_ratios' do
+      assert_equal 10.0, @p.statistics['buffer']['available_buffer_space_ratios']
+    end
+  end
 end

data/test/plugin/test_compressable.rb

@@ -4,6 +4,12 @@ require 'fluent/plugin/compressable'
 class CompressableTest < Test::Unit::TestCase
   include Fluent::Plugin::Compressable
 
+  def compress_assert_equal(expected, actual)
+    e = Zlib::GzipReader.new(StringIO.new(expected)).read
+    a = Zlib::GzipReader.new(StringIO.new(actual)).read
+    assert_equal(e, a)
+  end
+
   sub_test_case '#compress' do
     setup do
       @src = 'text data for compressing' * 5
@@ -18,8 +24,7 @@ class CompressableTest < Test::Unit::TestCase
     test 'write compressed data to IO with output_io option' do
       io = StringIO.new
       compress(@src, output_io: io)
-      waiting(10){ sleep 0.1 until @gzipped_src == io.string }
-      assert_equal @gzipped_src, io.string
+      compress_assert_equal @gzipped_src, io.string
     end
   end
 
@@ -36,7 +41,6 @@ class CompressableTest < Test::Unit::TestCase
     test 'write decompressed data to IO with output_io option' do
       io = StringIO.new
       decompress(@gzipped_src, output_io: io)
-      waiting(10){ sleep 0.1 until @src == io.string }
       assert_equal @src, io.string
     end
 
@@ -58,7 +62,6 @@ class CompressableTest < Test::Unit::TestCase
       output_io = StringIO.new
 
       decompress(input_io: input_io, output_io: output_io)
-      waiting(10){ sleep 0.1 until @src == output_io.string }
       assert_equal @src, output_io.string
     end
 

data/test/plugin/test_in_dummy.rb

@@ -95,21 +95,20 @@ class DummyTest < Test::Unit::TestCase
   TEST_PLUGIN_STORAGE_PATH = File.join( File.dirname(File.dirname(__FILE__)), 'tmp', 'in_dummy', 'store' )
   FileUtils.mkdir_p TEST_PLUGIN_STORAGE_PATH
 
-  sub_test_case "doesn't suspend internal counters in default" do
+  sub_test_case 'when dummy plugin has storage which is not specified the path'  do
     config1 = {
       'tag' => 'dummy',
-      'rate' => '2',
+      'rate' => '0',
       'dummy' => '[{"x": 1, "y": "1"}, {"x": 2, "y": "2"}, {"x": 3, "y": "3"}]',
       'auto_increment_key' => 'id',
-      'suspend' => false,
     }
     conf1 = config_element('ROOT', '', config1, [])
-    test "value of auto increment key is not suspended after stop-and-start" do
+    test "value of auto increment key is not kept after stop-and-start" do
       assert !File.exist?(File.join(TEST_PLUGIN_STORAGE_PATH, 'json', 'test-01.json'))
 
       d1 = create_driver(conf1)
       d1.run(timeout: 0.5) do
-        d1.instance.emit(4)
+        d1.instance.emit(2)
       end
 
       events = d1.events.sort{|a,b| a[2]['id'] <=> b[2]['id'] }
@@ -124,7 +123,7 @@ class DummyTest < Test::Unit::TestCase
 
       d2 = create_driver(conf1)
       d2.run(timeout: 0.5) do
-        d2.instance.emit(4)
+        d2.instance.emit(2)
       end
 
       events = d2.events.sort{|a,b| a[2]['id'] <=> b[2]['id'] }
@@ -136,7 +135,7 @@ class DummyTest < Test::Unit::TestCase
     end
   end
 
-  sub_test_case "suspend internal counters if suspend is true" do
+  sub_test_case 'when dummy plugin has storage which is specified the path'  do
     setup do
       FileUtils.rm_rf(TEST_PLUGIN_STORAGE_PATH)
       FileUtils.mkdir_p(File.join(TEST_PLUGIN_STORAGE_PATH, 'json'))
@@ -146,10 +145,9 @@ class DummyTest < Test::Unit::TestCase
     config2 = {
       '@id' => 'test-02',
       'tag' => 'dummy',
-      'rate' => '2',
+      'rate' => '0',
       'dummy' => '[{"x": 1, "y": "1"}, {"x": 2, "y": "2"}, {"x": 3, "y": "3"}]',
       'auto_increment_key' => 'id',
-      'suspend' => true,
     }
     conf2 = config_element('ROOT', '', config2, [
               config_element(
@@ -161,12 +159,12 @@ class DummyTest < Test::Unit::TestCase
                  'persistent' => true,
                 })
             ])
-    test "value of auto increment key is suspended after stop-and-start" do
+    test "value of auto increment key is kept after stop-and-start" do
       assert !File.exist?(File.join(TEST_PLUGIN_STORAGE_PATH, 'json', 'test-02.json'))
 
       d1 = create_driver(conf2)
-      d1.run(timeout: 0.5) do
-        d1.instance.emit(4)
+      d1.run(timeout: 1) do
+        d1.instance.emit(2)
       end
 
       first_id1 = d1.events.first[2]['id']
@@ -178,8 +176,8 @@ class DummyTest < Test::Unit::TestCase
       assert File.exist?(File.join(TEST_PLUGIN_STORAGE_PATH, 'json', 'test-02.json'))
 
       d2 = create_driver(conf2)
-      d2.run(timeout: 0.5) do
-        d2.instance.emit(4)
+      d2.run(timeout: 1) do
+        d2.instance.emit(2)
       end
       d2.events
 

data/test/plugin/test_in_forward.rb

@@ -218,7 +218,7 @@ class ForwardInputTest < Test::Unit::TestCase
         }
       end
 
-      assert_equal(records, d.events.sort_by {|a| a[1] })
+      assert_equal(records, d.events.sort_by {|a| a[0] })
     end
 
     test 'json_with_newline' do
@@ -237,7 +237,7 @@ class ForwardInputTest < Test::Unit::TestCase
         }
       end
 
-      assert_equal(records, d.events.sort_by {|a| a[1] })
+      assert_equal(records, d.events.sort_by {|a| a[0] })
     end
   end
 

data/test/plugin/test_in_gc_stat.rb

@@ -22,9 +22,14 @@ class GCStatInputTest < Test::Unit::TestCase
     assert_equal("t1", d.instance.tag)
   end
 
-  def test_emit
+  def setup_gc_stat
     stat = GC.stat
     stub(GC).stat { stat }
+    stat
+  end
+
+  def test_emit
+    stat = setup_gc_stat
 
     d = create_driver
     d.run(expect_emits: 2)
@@ -36,4 +41,22 @@ class GCStatInputTest < Test::Unit::TestCase
       assert(events[i][1].is_a?(Fluent::EventTime))
     }
   end
+
+  def test_emit_with_use_symbol_keys_false
+    stat = setup_gc_stat
+    result = {}
+    stat.each_pair { |k, v|
+      result[k.to_s] = v
+    }
+
+    d = create_driver(CONFIG + "use_symbol_keys false")
+    d.run(expect_emits: 2)
+
+    events = d.events
+    assert(events.length > 0)
+    events.each_index {|i|
+      assert_equal(result, events[i][2])
+      assert(events[i][1].is_a?(Fluent::EventTime))
+    }
+  end
 end

data/test/plugin/test_in_http.rb

@@ -116,6 +116,36 @@ class HttpInputTest < Test::Unit::TestCase
     assert_equal_event_time time, d.events[1][1]
   end
 
+  data('json' => ['json', :to_json],
+       'msgpack' => ['msgpack', :to_msgpack])
+  def test_default_with_time_format(data)
+    param, method_name = data
+    d = create_driver(CONFIG + %[
+      <parse>
+        keep_time_key
+        time_format %iso8601
+      </parse>
+    ])
+
+    time = event_time("2020-06-10T01:14:27+00:00")
+    events = [
+      ["tag1", time, {"a" => 1, "time" => '2020-06-10T01:14:27+00:00'}],
+      ["tag2", time, {"a" => 2, "time" => '2020-06-10T01:14:27+00:00'}],
+    ]
+    res_codes = []
+
+    d.run(expect_records: 2) do
+      events.each do |tag, t, record|
+        res = post("/#{tag}", {param => record.__send__(method_name)})
+        res_codes << res.code
+      end
+    end
+    assert_equal ["200", "200"], res_codes
+    assert_equal events, d.events
+    assert_equal_event_time time, d.events[0][1]
+    assert_equal_event_time time, d.events[1][1]
+  end
+
   def test_multi_json
     d = create_driver
     time = event_time("2011-01-02 13:14:15 UTC")
@@ -163,6 +193,33 @@ class HttpInputTest < Test::Unit::TestCase
     assert_equal_event_time time, d.events[1][1]
   end
 
+  data('json' => ['json', :to_json],
+       'msgpack' => ['msgpack', :to_msgpack])
+  def test_default_multi_with_time_format(data)
+    param, method_name = data
+    d = create_driver(CONFIG + %[
+      <parse>
+        keep_time_key
+        time_format %iso8601
+      </parse>
+    ])
+    time = event_time("2020-06-10T01:14:27+00:00")
+    events = [
+      ["tag1", time, {'a' => 1, 'time' => "2020-06-10T01:14:27+00:00"}],
+      ["tag1", time, {'a' => 2, 'time' => "2020-06-10T01:14:27+00:00"}],
+    ]
+    tag = "tag1"
+    res_codes = []
+    d.run(expect_records: 2, timeout: 5) do
+      res = post("/#{tag}", {param => events.map { |e| e[2] }.__send__(method_name)})
+      res_codes << res.code
+    end
+    assert_equal ["200"], res_codes
+    assert_equal events, d.events
+    assert_equal_event_time time, d.events[0][1]
+    assert_equal_event_time time, d.events[1][1]
+  end
+
   def test_multi_json_with_nonexistent_time_key
     d = create_driver(CONFIG + %[
       <parse>

data/test/plugin/test_in_syslog.rb

@@ -163,6 +163,21 @@ EOS
     compare_test_result(d.events, tests)
   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"))
+    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.send(msg, 0)
+    end
+
+    tag, _, event = d.events[0]
+    assert_equal('syslog.kern.alert', tag)
+    assert_equal('kern', event['pri'])
+  end
+
   def test_msg_size_with_same_tcp_connection
     d = create_driver([CONFIG, "<transport tcp> \n</transport>"].join("\n"))
     tests = create_test_case
@@ -360,7 +375,7 @@ EOS
       ]
       msgs.each { |msg|
         m = msg['msg']
-        msg['msg'] = "#{m.size + 1} #{m}"
+        msg['msg'] = "#{m.size} #{m}"
       }
       msgs
     end

data/test/plugin/test_in_tail.rb

@@ -23,9 +23,6 @@ class TailInputTest < Test::Unit::TestCase
   def cleanup_directory(path)
     FileUtils.rm_rf(path, secure: true)
     if File.exist?(path)
-      # ensure files are closed for Windows, on which deleted files
-      # are still visible from filesystem
-      GC.start(full_mark: true, immediate_mark: true, immediate_sweep: true)
       FileUtils.remove_entry_secure(path, true)
     end
     FileUtils.mkdir_p(path)
@@ -105,6 +102,12 @@ class TailInputTest < Test::Unit::TestCase
       assert_equal ["tail.txt", "test2", "tmp,dev"], d.instance.paths
     end
 
+    test "multi paths with same path configured twice" do
+      c = config_element("ROOT", "", { "path" => "test1.txt,test2.txt,test1.txt", "tag" => "t1", "path_delimiter" => "," })
+      d = create_driver(c + PARSE_SINGLE_LINE_CONFIG, false)
+      assert_equal ["test2.txt","test1.txt"].sort, d.instance.paths.sort
+    end
+
     test "multi paths with invaid path_delimiter" do
       c = config_element("ROOT", "", { "path" => "tail.txt|test2|tmp,dev", "tag" => "t1", "path_delimiter" => "*" })
       assert_raise(Fluent::ConfigError) do
@@ -226,7 +229,7 @@ class TailInputTest < Test::Unit::TestCase
       d = create_driver(config)
       msg = 'test' * 2000 # in_tail reads 8192 bytes at once.
 
-      d.run(expect_emits: 1) do
+      d.run(expect_emits: num_events, timeout: 1) do
         File.open("#{TMP_DIR}/tail.txt", "ab") {|f|
           f.puts msg
           f.puts msg
@@ -237,7 +240,7 @@ class TailInputTest < Test::Unit::TestCase
       assert_equal(true, events.length > 0)
       assert_equal({"message" => msg}, events[0][2])
       assert_equal({"message" => msg}, events[1][2])
-      assert_equal(num_events, d.emit_count)
+      assert num_events <= d.emit_count
     end
 
     data(flat: CONFIG_READ_FROM_HEAD + SINGLE_LINE_CONFIG,
@@ -1025,6 +1028,17 @@ class TailInputTest < Test::Unit::TestCase
       assert_equal EX_PATHS - [EX_PATHS.last], plugin.expand_paths.sort
     end
 
+    def test_expand_paths_with_duplicate_configuration
+      expanded_paths = [
+        'test/plugin/data/log/foo/bar.log',
+        'test/plugin/data/log/test.log'
+      ]
+      duplicate_config = EX_CONFIG.dup
+      duplicate_config["path"]="test/plugin/data/log/**/*.log, test/plugin/data/log/**/*.log"
+      plugin = create_driver(EX_CONFIG, false).instance
+      assert_equal expanded_paths, plugin.expand_paths.sort
+    end
+
     def test_expand_paths_with_timezone
       ['Asia/Taipei', '+08'].each do |tz_type|
         taipei_config = EX_CONFIG + config_element("", "", {"path_timezone" => tz_type})
@@ -1065,9 +1079,6 @@ class TailInputTest < Test::Unit::TestCase
       assert_equal expected_files, plugin.expand_paths.sort
     end
 
-    # For https://github.com/fluent/fluentd/issues/1455
-    # This test is fragile because test content depends on internal implementation.
-    # So if you modify in_tail internal, this test may break.
     def test_unwatched_files_should_be_removed
       config = config_element("", "", {
                                 "tag" => "tail",
@@ -1078,23 +1089,16 @@ class TailInputTest < Test::Unit::TestCase
                                 "refresh_interval" => 1,
                               })
       d = create_driver(config, false)
+      d.end_if { d.instance.instance_variable_get(:@tails).keys.size >= 1 }
       d.run(expect_emits: 1, shutdown: false) do
         File.open("#{TMP_DIR}/tail.txt", "ab") { |f| f.puts "test3\n" }
       end
 
-      assert_equal 1, d.instance.instance_variable_get(:@tails).keys.size
       cleanup_directory(TMP_DIR)
       waiting(20) { sleep 0.1 until Dir.glob("#{TMP_DIR}/*.txt").size == 0 } # Ensure file is deleted on Windows
-      waiting(5) { sleep 0.1 until d.instance.instance_variable_get(:@tails).keys.size == 0 }
+      waiting(5) { sleep 0.1 until d.instance.instance_variable_get(:@tails).keys.size <= 0 }
 
-      # Previous implementation has an infinite watcher creation bug.
-      # Following code checks such unexpected bug by counting actual object allocation.
-      base_num = count_timer_object
-      2.times {
-        sleep 1
-        num = count_timer_object
-        assert_equal base_num, num
-      }
+      assert_equal 0, d.instance.instance_variable_get(:@tails).keys.size
 
       d.instance_shutdown
     end
@@ -1164,7 +1168,7 @@ class TailInputTest < Test::Unit::TestCase
 
     Timecop.freeze(2010, 1, 2, 3, 4, 5) do
       EX_PATHS.each do |path|
-        mock.proxy(Fluent::Plugin::TailInput::TailWatcher).new(path, anything, anything, true, 1000, anything, anything, anything, anything, false).once
+        mock.proxy(Fluent::Plugin::TailInput::TailWatcher).new(path, anything, anything, true, anything, nil, anything).once
       end
 
       plugin.refresh_watchers
@@ -1173,7 +1177,7 @@ class TailInputTest < Test::Unit::TestCase
     mock.proxy(plugin).detach_watcher_after_rotate_wait(plugin.instance_variable_get(:@tails)['test/plugin/data/2010/01/20100102-030405.log'])
 
     Timecop.freeze(2010, 1, 2, 3, 4, 6) do
-      mock.proxy(Fluent::Plugin::TailInput::TailWatcher).new('test/plugin/data/2010/01/20100102-030406.log', anything, anything, true, 1000, anything, anything, anything, anything, false).once
+      mock.proxy(Fluent::Plugin::TailInput::TailWatcher).new('test/plugin/data/2010/01/20100102-030406.log', anything, anything, true, anything, nil, anything).once
       plugin.refresh_watchers
 
       flexstub(Fluent::Plugin::TailInput::TailWatcher) do |watcherclass|
@@ -1183,6 +1187,25 @@ class TailInputTest < Test::Unit::TestCase
     end
   end
 
+  sub_test_case "refresh of pos file" do
+    test 'type of pos_file_compaction_interval is time' do
+      tail = {
+        "tag" => "tail",
+        "path" => "#{TMP_DIR}/*.txt",
+        "format" => "none",
+        "pos_file" => "#{TMP_DIR}/pos/tail.pos",
+        "refresh_interval" => 1,
+        "read_from_head" => true,
+        'pos_file_compaction_interval' => '24h',
+      }
+      config = config_element("", "", tail)
+      d = create_driver(config, false)
+      mock(d.instance).timer_execute(:in_tail_refresh_watchers, 1.0).once
+      mock(d.instance).timer_execute(:in_tail_refresh_compact_pos_file, 60 * 60 * 24).once
+      d.run                     # call start
+    end
+  end
+
   sub_test_case "receive_lines" do
     DummyWatcher = Struct.new("DummyWatcher", :tag)