fluentd 1.15.3-x86-mingw32 → 1.16.2-x86-mingw32

data/test/plugin/test_output.rb

@@ -447,25 +447,25 @@ class OutputTest < Test::Unit::TestCase
         @i.configure(config_element('ROOT', '', {}, [config_element('buffer', '')]))
         validators = @i.placeholder_validators(:path, "/my/path/${tag}/${username}/file.%Y%m%d_%H%M.log")
         assert_equal 3, validators.size
-        assert_equal 1, validators.select(&:time?).size
-        assert_equal 1, validators.select(&:tag?).size
-        assert_equal 1, validators.select(&:keys?).size
+        assert_equal 1, validators.count(&:time?)
+        assert_equal 1, validators.count(&:tag?)
+        assert_equal 1, validators.count(&:keys?)
       end
 
       test 'returns validators for time, tag and keys when a plugin is configured with these keys even if a template does not have placeholders' do
         @i.configure(config_element('ROOT', '', {}, [config_element('buffer', 'time,tag,username', {'timekey' => 60})]))
         validators = @i.placeholder_validators(:path, "/my/path/file.log")
         assert_equal 3, validators.size
-        assert_equal 1, validators.select(&:time?).size
-        assert_equal 1, validators.select(&:tag?).size
-        assert_equal 1, validators.select(&:keys?).size
+        assert_equal 1, validators.count(&:time?)
+        assert_equal 1, validators.count(&:tag?)
+        assert_equal 1, validators.count(&:keys?)
       end
 
       test 'returns a validator for time if a template has timestamp placeholders' do
         @i.configure(config_element('ROOT', '', {}, [config_element('buffer', '')]))
         validators = @i.placeholder_validators(:path, "/my/path/file.%Y-%m-%d.log")
         assert_equal 1, validators.size
-        assert_equal 1, validators.select(&:time?).size
+        assert_equal 1, validators.count(&:time?)
         assert_raise Fluent::ConfigError.new("Parameter 'path: /my/path/file.%Y-%m-%d.log' has timestamp placeholders, but chunk key 'time' is not configured") do
           validators.first.validate!
         end
@@ -475,7 +475,7 @@ class OutputTest < Test::Unit::TestCase
         @i.configure(config_element('ROOT', '', {}, [config_element('buffer', 'time', {'timekey' => '30'})]))
         validators = @i.placeholder_validators(:path, "/my/path/to/file.log")
         assert_equal 1, validators.size
-        assert_equal 1, validators.select(&:time?).size
+        assert_equal 1, validators.count(&:time?)
         assert_raise Fluent::ConfigError.new("Parameter 'path: /my/path/to/file.log' doesn't have timestamp placeholders for timekey 30") do
           validators.first.validate!
         end
@@ -485,7 +485,7 @@ class OutputTest < Test::Unit::TestCase
         @i.configure(config_element('ROOT', '', {}, [config_element('buffer', '')]))
         validators = @i.placeholder_validators(:path, "/my/path/${tag}/file.log")
         assert_equal 1, validators.size
-        assert_equal 1, validators.select(&:tag?).size
+        assert_equal 1, validators.count(&:tag?)
         assert_raise Fluent::ConfigError.new("Parameter 'path: /my/path/${tag}/file.log' has tag placeholders, but chunk key 'tag' is not configured") do
           validators.first.validate!
         end
@@ -495,7 +495,7 @@ class OutputTest < Test::Unit::TestCase
         @i.configure(config_element('ROOT', '', {}, [config_element('buffer', 'tag')]))
         validators = @i.placeholder_validators(:path, "/my/path/file.log")
         assert_equal 1, validators.size
-        assert_equal 1, validators.select(&:tag?).size
+        assert_equal 1, validators.count(&:tag?)
         assert_raise Fluent::ConfigError.new("Parameter 'path: /my/path/file.log' doesn't have tag placeholder") do
           validators.first.validate!
         end
@@ -505,7 +505,7 @@ class OutputTest < Test::Unit::TestCase
         @i.configure(config_element('ROOT', '', {}, [config_element('buffer', '')]))
         validators = @i.placeholder_validators(:path, "/my/path/${username}/file.${group}.log")
         assert_equal 1, validators.size
-        assert_equal 1, validators.select(&:keys?).size
+        assert_equal 1, validators.count(&:keys?)
         assert_raise Fluent::ConfigError.new("Parameter 'path: /my/path/${username}/file.${group}.log' has placeholders, but chunk keys doesn't have keys group,username") do
           validators.first.validate!
         end
@@ -515,7 +515,7 @@ class OutputTest < Test::Unit::TestCase
         @i.configure(config_element('ROOT', '', {}, [config_element('buffer', 'username,group')]))
         validators = @i.placeholder_validators(:path, "/my/path/file.log")
         assert_equal 1, validators.size
-        assert_equal 1, validators.select(&:keys?).size
+        assert_equal 1, validators.count(&:keys?)
         assert_raise Fluent::ConfigError.new("Parameter 'path: /my/path/file.log' doesn't have enough placeholders for keys group,username") do
           validators.first.validate!
         end
@@ -803,7 +803,10 @@ class OutputTest < Test::Unit::TestCase
     end
 
     test 'output plugin will call #try_write for plugin supports delayed commit only to flush buffer chunks' do
+      tmp_dir = File.join(__dir__, '../tmp/test_output')
+
       i = create_output(:delayed)
+      i.system_config_override(root_dir: tmp_dir) # Backup files are generated in `tmp_dir`.
       try_write_called = false
       i.register(:try_write){|chunk| try_write_called = true; commit_write(chunk.unique_id) }
 
@@ -820,6 +823,8 @@ class OutputTest < Test::Unit::TestCase
       assert try_write_called
 
       i.stop; i.before_shutdown; i.shutdown; i.after_shutdown; i.close; i.terminate
+    ensure
+      FileUtils.rm_rf(tmp_dir)
     end
 
     test '#prefer_delayed_commit (returns false) decides delayed commit is disabled if both are implemented' do
@@ -849,7 +854,10 @@ class OutputTest < Test::Unit::TestCase
     end
 
     test '#prefer_delayed_commit (returns true) decides delayed commit is enabled if both are implemented' do
+      tmp_dir = File.join(__dir__, '../tmp/test_output')
+
       i = create_output(:full)
+      i.system_config_override(root_dir: tmp_dir) # Backup files are generated in `tmp_dir`.
       write_called = false
       try_write_called = false
       i.register(:write){ |chunk| write_called = true }
@@ -872,6 +880,8 @@ class OutputTest < Test::Unit::TestCase
       assert try_write_called
 
       i.stop; i.before_shutdown; i.shutdown; i.after_shutdown; i.close; i.terminate
+    ensure
+      FileUtils.rm_rf(tmp_dir)
     end
 
     test 'flush_interval is ignored when flush_mode is not interval' do
@@ -1062,4 +1072,263 @@ class OutputTest < Test::Unit::TestCase
       }
     end
   end
+
+  sub_test_case "actual_flush_thread_count" do
+    data(
+      "Not buffered",
+      {
+        output_type: :sync,
+        config: config_element(),
+        expected: 0,
+      }
+    )
+    data(
+      "Buffered with singile thread",
+      {
+        output_type: :full,
+        config: config_element("ROOT", "", {}, [config_element("buffer", "", {})]),
+        expected: 1,
+      }
+    )
+    data(
+      "Buffered with multiple threads",
+      {
+        output_type: :full,
+        config: config_element("ROOT", "", {}, [config_element("buffer", "", {"flush_thread_count" => 8})]),
+        expected: 8,
+      }
+    )
+    test "actual_flush_thread_count" do |data|
+      o = create_output(data[:output_type])
+      o.configure(data[:config])
+      assert_equal data[:expected], o.actual_flush_thread_count
+    end
+
+    data(
+      "Buffered with single thread",
+      {
+        output_type: :full,
+        config: config_element(
+          "ROOT", "", {},
+          [
+            config_element("buffer", "", {}), 
+            config_element("secondary", "", {"@type" => "test", "name" => "test"}),
+          ]
+        ),
+        expected: 1,
+      }
+    )
+    data(
+      "Buffered with multiple threads",
+      {
+        output_type: :full,
+        config: config_element(
+          "ROOT", "", {},
+          [
+            config_element("buffer", "", {"flush_thread_count" => 8}),
+            config_element("secondary", "", {"@type" => "test", "name" => "test"}),
+          ]
+        ),
+        expected: 8,
+      }
+    )
+    test "actual_flush_thread_count for secondary" do |data|
+      primary = create_output(data[:output_type])
+      primary.configure(data[:config])
+      assert_equal data[:expected], primary.secondary.actual_flush_thread_count
+    end
+  end
+
+  sub_test_case "synchronize_path" do
+    def setup
+      Dir.mktmpdir do |lock_dir|
+        ENV['FLUENTD_LOCK_DIR'] = lock_dir
+        yield
+      end
+    end
+
+    def assert_worker_lock(lock_path, expect_locked)
+      # With LOCK_NB set, flock() returns:
+      #   * `false` when the file is already locked.
+      #   * `0` when the file is not locked.
+      File.open(lock_path, "w") do |f|
+        if expect_locked
+          assert_equal false, f.flock(File::LOCK_EX|File::LOCK_NB)
+        else
+          assert_equal 0, f.flock(File::LOCK_EX|File::LOCK_NB)
+        end
+      end
+    end
+
+    def assert_thread_lock(output_plugin, expect_locked)
+      t = Thread.new do
+        output_plugin.synchronize_path("test") do
+        end
+      end
+      if expect_locked
+        assert_nil t.join(3)
+      else
+        assert_not_nil t.join(3)
+      end
+    end
+
+    data(
+      "Not buffered with single worker",
+      {
+        output_type: :sync,
+        config: config_element(),
+        workers: 1,
+        expect_worker_lock: false,
+        expect_thread_lock: false,
+      }
+    )
+    data(
+      "Not buffered with multiple workers",
+      {
+        output_type: :sync,
+        config: config_element(),
+        workers: 4,
+        expect_worker_lock: true,
+        expect_thread_lock: false,
+      }
+    )
+    data(
+      "Buffered with single thread and single worker",
+      {
+        output_type: :full,
+        config: config_element("ROOT", "", {}, [config_element("buffer", "", {})]),
+        workers: 1,
+        expect_worker_lock: false,
+        expect_thread_lock: false,
+      }
+    )
+    data(
+      "Buffered with multiple threads and single worker",
+      {
+        output_type: :full,
+        config: config_element("ROOT", "", {}, [config_element("buffer", "", {"flush_thread_count" => 8})]),
+        workers: 1,
+        expect_worker_lock: false,
+        expect_thread_lock: true,
+      }
+    )
+    data(
+      "Buffered with single thread and multiple workers",
+      {
+        output_type: :full,
+        config: config_element("ROOT", "", {}, [config_element("buffer", "", {})]),
+        workers: 4,
+        expect_worker_lock: true,
+        expect_thread_lock: false,
+      }
+    )
+    data(
+      "Buffered with multiple threads and multiple workers",
+      {
+        output_type: :full,
+        config: config_element("ROOT", "", {}, [config_element("buffer", "", {"flush_thread_count" => 8})]),
+        workers: 4,
+        expect_worker_lock: true,
+        expect_thread_lock: true,
+      }
+    )
+    test "synchronize_path" do |data|
+      o = create_output(data[:output_type])
+      o.configure(data[:config])
+      o.system_config_override(workers: data[:workers])
+
+      test_lock_name = "test_lock_name"
+      lock_path = o.get_lock_path(test_lock_name)
+
+      o.synchronize_path(test_lock_name) do
+        assert_worker_lock(lock_path, data[:expect_worker_lock])
+        assert_thread_lock(o, data[:expect_thread_lock])
+      end
+
+      assert_worker_lock(lock_path, false)
+      assert_thread_lock(o, false)
+    end
+
+    data(
+      "Buffered with single thread and single worker",
+      {
+        output_type: :full,
+        config: config_element(
+          "ROOT", "", {},
+          [
+            config_element("buffer", "", {}),
+            config_element("secondary", "", {"@type" => "test", "name" => "test"}),
+          ]
+        ),
+        workers: 1,
+        expect_worker_lock: false,
+        expect_thread_lock: false,
+      }
+    )
+    data(
+      "Buffered with multiple threads and single worker",
+      {
+        output_type: :full,
+        config: config_element(
+          "ROOT", "", {},
+          [
+            config_element("buffer", "", {"flush_thread_count" => 8}),
+            config_element("secondary", "", {"@type" => "test", "name" => "test"}),
+          ]
+        ),
+        workers: 1,
+        expect_worker_lock: false,
+        expect_thread_lock: true,
+      }
+    )
+    data(
+      "Buffered with single thread and multiple workers",
+      {
+        output_type: :full,
+        config: config_element(
+          "ROOT", "", {},
+          [
+            config_element("buffer", "", {}),
+            config_element("secondary", "", {"@type" => "test", "name" => "test"}),
+          ]
+        ),
+        workers: 4,
+        expect_worker_lock: true,
+        expect_thread_lock: false,
+      }
+    )
+    data(
+      "Buffered with multiple threads and multiple workers",
+      {
+        output_type: :full,
+        config: config_element(
+          "ROOT", "", {},
+          [
+            config_element("buffer", "", {"flush_thread_count" => 8}),
+            config_element("secondary", "", {"@type" => "test", "name" => "test"}),
+          ]
+        ),
+        workers: 4,
+        expect_worker_lock: true,
+        expect_thread_lock: true,
+      }
+    )
+    test "synchronize_path for secondary" do |data|
+      primary = create_output(data[:output_type])
+      primary.configure(data[:config])
+      secondary = primary.secondary
+      secondary.system_config_override(workers: data[:workers])
+
+      test_lock_name = "test_lock_name"
+      lock_path = secondary.get_lock_path(test_lock_name)
+
+      secondary.synchronize_path(test_lock_name) do
+        assert_worker_lock(lock_path, data[:expect_worker_lock])
+        assert_thread_lock(secondary, data[:expect_thread_lock])
+      end
+
+      assert_worker_lock(lock_path, false)
+      assert_thread_lock(secondary, false)
+    end
+  end
 end

data/test/plugin/test_output_as_buffered.rb

@@ -510,7 +510,7 @@ class BufferedOutputTest < Test::Unit::TestCase
       logs = @i.log.out.logs.dup
       @i.start
       @i.after_start
-      assert{ logs.select{|log| log.include?('[warn]') }.size == 0 }
+      assert{ logs.count{|log| log.include?('[warn]') } == 0 }
     end
 
     test 'a warning reported with 4 chunk keys' do
@@ -522,7 +522,7 @@ class BufferedOutputTest < Test::Unit::TestCase
       @i.after_start
       assert_equal ['key1', 'key2', 'key3', 'key4'], @i.chunk_keys
 
-      assert{ logs.select{|log| log.include?('[warn]: many chunk keys specified, and it may cause too many chunks on your system.') }.size == 1 }
+      assert{ logs.count{|log| log.include?('[warn]: many chunk keys specified, and it may cause too many chunks on your system.') } == 1 }
     end
 
     test 'a warning reported with 4 chunk keys including "tag"' do
@@ -531,7 +531,7 @@ class BufferedOutputTest < Test::Unit::TestCase
       logs = @i.log.out.logs.dup
       @i.start # this calls `log.reset`... capturing logs about configure must be done before this line
       @i.after_start
-      assert{ logs.select{|log| log.include?('[warn]: many chunk keys specified, and it may cause too many chunks on your system.') }.size == 1 }
+      assert{ logs.count{|log| log.include?('[warn]: many chunk keys specified, and it may cause too many chunks on your system.') } == 1 }
     end
 
     test 'time key is not included for warned chunk keys' do
@@ -540,7 +540,7 @@ class BufferedOutputTest < Test::Unit::TestCase
       logs = @i.log.out.logs.dup
       @i.start
       @i.after_start
-      assert{ logs.select{|log| log.include?('[warn]') }.size == 0 }
+      assert{ logs.count{|log| log.include?('[warn]') } == 0 }
     end
   end
 
@@ -968,8 +968,8 @@ class BufferedOutputTest < Test::Unit::TestCase
       waiting(4){ sleep 0.1 until ary.size == 3 }
 
       assert_equal 3, ary.size
-      assert_equal 2, ary.select{|e| e[0] == "test.tag.1" }.size
-      assert_equal 1, ary.select{|e| e[0] == "test.tag.2" }.size
+      assert_equal 2, ary.count{|e| e[0] == "test.tag.1" }
+      assert_equal 1, ary.count{|e| e[0] == "test.tag.2" }
 
       Timecop.freeze( Time.parse('2016-04-13 14:04:04 +0900') )
 
@@ -985,8 +985,8 @@ class BufferedOutputTest < Test::Unit::TestCase
       assert{ @i.buffer.stage.size == 1 && @i.write_count == 2 }
 
       assert_equal 9, ary.size
-      assert_equal 7, ary.select{|e| e[0] == "test.tag.1" }.size
-      assert_equal 2, ary.select{|e| e[0] == "test.tag.2" }.size
+      assert_equal 7, ary.count{|e| e[0] == "test.tag.1" }
+      assert_equal 2, ary.count{|e| e[0] == "test.tag.2" }
 
       assert metachecks.all?{|e| e }
     end
@@ -1224,8 +1224,8 @@ class BufferedOutputTest < Test::Unit::TestCase
 
       # events fulfills a chunk (and queued immediately)
       assert_equal 5, ary.size
-      assert_equal 5, ary.select{|e| e[0] == "test.tag.1" }.size
-      assert_equal 0, ary.select{|e| e[0] == "test.tag.2" }.size
+      assert_equal 5, ary.count{|e| e[0] == "test.tag.1" }
+      assert_equal 0, ary.count{|e| e[0] == "test.tag.2" }
 
       Timecop.freeze( Time.parse('2016-04-13 14:04:09 +0900') )
 
@@ -1249,8 +1249,8 @@ class BufferedOutputTest < Test::Unit::TestCase
       assert{ @i.buffer.stage.size == 0 && @i.write_count == 3 }
 
       assert_equal 11, ary.size
-      assert_equal 8, ary.select{|e| e[0] == "test.tag.1" }.size
-      assert_equal 3, ary.select{|e| e[0] == "test.tag.2" }.size
+      assert_equal 8, ary.count{|e| e[0] == "test.tag.1" }
+      assert_equal 3, ary.count{|e| e[0] == "test.tag.2" }
 
       assert metachecks.all?{|e| e }
     end
@@ -1315,8 +1315,8 @@ class BufferedOutputTest < Test::Unit::TestCase
 
       # events fulfills a chunk (and queued immediately)
       assert_equal 5, ary.size
-      assert_equal 5, ary.select{|e| e[0] == "test.tag.1" }.size
-      assert_equal 0, ary.select{|e| e[0] == "test.tag.2" }.size
+      assert_equal 5, ary.count{|e| e[0] == "test.tag.1" }
+      assert_equal 0, ary.count{|e| e[0] == "test.tag.2" }
 
       @i.stop
       @i.before_shutdown
@@ -1330,8 +1330,8 @@ class BufferedOutputTest < Test::Unit::TestCase
       assert{ @i.buffer.stage.size == 0 && @i.buffer.queue.size == 0 && @i.write_count == 3 }
 
       assert_equal 11, ary.size
-      assert_equal 8, ary.select{|e| e[0] == "test.tag.1" }.size
-      assert_equal 3, ary.select{|e| e[0] == "test.tag.2" }.size
+      assert_equal 8, ary.count{|e| e[0] == "test.tag.1" }
+      assert_equal 3, ary.count{|e| e[0] == "test.tag.2" }
 
       assert metachecks.all?{|e| e }
     end
@@ -1435,8 +1435,8 @@ class BufferedOutputTest < Test::Unit::TestCase
 
       # events fulfills a chunk (and queued immediately)
       assert_equal 5, ary.size
-      assert_equal 5, ary.select{|e| e[0] == "test.tag.1" }.size
-      assert_equal 0, ary.select{|e| e[0] == "test.tag.2" }.size
+      assert_equal 5, ary.count{|e| e[0] == "test.tag.1" }
+      assert_equal 0, ary.count{|e| e[0] == "test.tag.2" }
       assert ary[0...5].all?{|e| e[2]["name"] == "xxx" && e[2]["service"] == "a" }
 
       Timecop.freeze( Time.parse('2016-04-13 14:04:09 +0900') )
@@ -1465,11 +1465,11 @@ class BufferedOutputTest < Test::Unit::TestCase
       assert{ @i.buffer.stage.size == 0 && @i.write_count == 4 }
 
       assert_equal 11, ary.size
-      assert_equal 8, ary.select{|e| e[0] == "test.tag.1" }.size
-      assert_equal 3, ary.select{|e| e[0] == "test.tag.2" }.size
-      assert_equal 6, ary.select{|e| e[2]["name"] == "xxx" && e[2]["service"] == "a" }.size
-      assert_equal 3, ary.select{|e| e[2]["name"] == "yyy" && e[2]["service"] == "a" }.size
-      assert_equal 2, ary.select{|e| e[2]["name"] == "xxx" && e[2]["service"] == "b" }.size
+      assert_equal 8, ary.count{|e| e[0] == "test.tag.1" }
+      assert_equal 3, ary.count{|e| e[0] == "test.tag.2" }
+      assert_equal 6, ary.count{|e| e[2]["name"] == "xxx" && e[2]["service"] == "a" }
+      assert_equal 3, ary.count{|e| e[2]["name"] == "yyy" && e[2]["service"] == "a" }
+      assert_equal 2, ary.count{|e| e[2]["name"] == "xxx" && e[2]["service"] == "b" }
 
       assert metachecks.all?{|e| e }
     end
@@ -1525,8 +1525,8 @@ class BufferedOutputTest < Test::Unit::TestCase
 
       # events fulfills a chunk (and queued immediately)
       assert_equal 5, ary.size
-      assert_equal 5, ary.select{|e| e[0] == "test.tag.1" }.size
-      assert_equal 0, ary.select{|e| e[0] == "test.tag.2" }.size
+      assert_equal 5, ary.count{|e| e[0] == "test.tag.1" }
+      assert_equal 0, ary.count{|e| e[0] == "test.tag.2" }
 
       @i.stop
       @i.before_shutdown
@@ -1540,11 +1540,11 @@ class BufferedOutputTest < Test::Unit::TestCase
       assert{ @i.buffer.stage.size == 0 && @i.buffer.queue.size == 0 && @i.write_count == 4 }
 
       assert_equal 11, ary.size
-      assert_equal 8, ary.select{|e| e[0] == "test.tag.1" }.size
-      assert_equal 3, ary.select{|e| e[0] == "test.tag.2" }.size
-      assert_equal 6, ary.select{|e| e[2]["name"] == "xxx" && e[2]["service"] == "a" }.size
-      assert_equal 3, ary.select{|e| e[2]["name"] == "yyy" && e[2]["service"] == "a" }.size
-      assert_equal 2, ary.select{|e| e[2]["name"] == "xxx" && e[2]["service"] == "b" }.size
+      assert_equal 8, ary.count{|e| e[0] == "test.tag.1" }
+      assert_equal 3, ary.count{|e| e[0] == "test.tag.2" }
+      assert_equal 6, ary.count{|e| e[2]["name"] == "xxx" && e[2]["service"] == "a" }
+      assert_equal 3, ary.count{|e| e[2]["name"] == "yyy" && e[2]["service"] == "a" }
+      assert_equal 2, ary.count{|e| e[2]["name"] == "xxx" && e[2]["service"] == "b" }
 
       assert metachecks.all?{|e| e }
     end
@@ -1683,8 +1683,8 @@ class BufferedOutputTest < Test::Unit::TestCase
 
       # events fulfills a chunk (and queued immediately)
       assert_equal 5, ary.size
-      assert_equal 5, ary.select{|e| e[0] == "test.tag.1" }.size
-      assert_equal 0, ary.select{|e| e[0] == "test.tag.2" }.size
+      assert_equal 5, ary.count{|e| e[0] == "test.tag.1" }
+      assert_equal 0, ary.count{|e| e[0] == "test.tag.2" }
 
       assert_equal 1, chunks.size
       assert !chunks.first.empty?
@@ -1716,8 +1716,8 @@ class BufferedOutputTest < Test::Unit::TestCase
       assert{ @i.buffer.dequeued.size == 3 }
 
       assert_equal 11, ary.size
-      assert_equal 8, ary.select{|e| e[0] == "test.tag.1" }.size
-      assert_equal 3, ary.select{|e| e[0] == "test.tag.2" }.size
+      assert_equal 8, ary.count{|e| e[0] == "test.tag.1" }
+      assert_equal 3, ary.count{|e| e[0] == "test.tag.2" }
 
       assert_equal 3, chunks.size
       assert chunks.all?{|c| !c.empty? }
@@ -1802,8 +1802,8 @@ class BufferedOutputTest < Test::Unit::TestCase
 
       # events fulfills a chunk (and queued immediately)
       assert_equal 5, ary.size
-      assert_equal 5, ary.select{|e| e[0] == "test.tag.1" }.size
-      assert_equal 0, ary.select{|e| e[0] == "test.tag.2" }.size
+      assert_equal 5, ary.count{|e| e[0] == "test.tag.1" }
+      assert_equal 0, ary.count{|e| e[0] == "test.tag.2" }
 
       assert_equal 1, chunks.size
       assert !chunks.first.empty?
@@ -1835,8 +1835,8 @@ class BufferedOutputTest < Test::Unit::TestCase
       assert{ @i.buffer.dequeued.size == 3 }
 
       assert_equal 11, ary.size
-      assert_equal 8, ary.select{|e| e[0] == "test.tag.1" }.size
-      assert_equal 3, ary.select{|e| e[0] == "test.tag.2" }.size
+      assert_equal 8, ary.count{|e| e[0] == "test.tag.1" }
+      assert_equal 3, ary.count{|e| e[0] == "test.tag.2" }
 
       assert_equal 3, chunks.size
       assert chunks.all?{|c| !c.empty? }
@@ -1892,8 +1892,8 @@ class BufferedOutputTest < Test::Unit::TestCase
 
       assert{ @i.write_count == 7 }
       assert_equal 11, ary.size
-      assert_equal 8, ary.select{|e| e[0] == "test.tag.1" }.size
-      assert_equal 3, ary.select{|e| e[0] == "test.tag.2" }.size
+      assert_equal 8, ary.count{|e| e[0] == "test.tag.1" }
+      assert_equal 3, ary.count{|e| e[0] == "test.tag.2" }
       assert{ chunks.size == 3 }
       assert{ chunks.all?{|c| !c.empty? } }
 
@@ -1963,8 +1963,8 @@ class BufferedOutputTest < Test::Unit::TestCase
 
       # events fulfills a chunk (and queued immediately)
       assert_equal 5, ary.size
-      assert_equal 5, ary.select{|e| e[0] == "test.tag.1" }.size
-      assert_equal 0, ary.select{|e| e[0] == "test.tag.2" }.size
+      assert_equal 5, ary.count{|e| e[0] == "test.tag.1" }
+      assert_equal 0, ary.count{|e| e[0] == "test.tag.2" }
 
       assert_equal 1, chunks.size
       assert !chunks.first.empty?
@@ -1999,8 +1999,8 @@ class BufferedOutputTest < Test::Unit::TestCase
       assert{ @i.rollback_count == 0 }
 
       assert_equal 11, ary.size
-      assert_equal 8, ary.select{|e| e[0] == "test.tag.1" }.size
-      assert_equal 3, ary.select{|e| e[0] == "test.tag.2" }.size
+      assert_equal 8, ary.count{|e| e[0] == "test.tag.1" }
+      assert_equal 3, ary.count{|e| e[0] == "test.tag.2" }
 
       assert{ chunks.size == 3 }
       assert{ chunks.all?{|c| !c.empty? } }