fluentd 1.9.0.rc2 → 1.9.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: d435419feb5d6622dfcfcaa8e464234a0ba8aa73abd501d61521568982c33736
-  data.tar.gz: 0a153fdfa008135008379514314c42575495004ba9f7fb49ce6d39c8fa647713
+  metadata.gz: 27b8afc3247102ea42612c63559beda8c597b9d5365ea80840e543d6ebd74227
+  data.tar.gz: c74a703d9fdca1e392233725c89d26a84bf21d2177ed34b1f9904cca317ece7c
 SHA512:
-  metadata.gz: fd0d19edc1817113632a530c931d155a46dce8af3bbc9c2b511c835dcb4ee69397a58e1af297ada745d4882008e58fbddba8beba9eb3f01c88120ffed716059b
-  data.tar.gz: b57a69591accb5eb39620afe1aeb0fbf39c171a431979349b110b15ad2892424bee5a28c4dbd7aad24ad1d19d3881759b86ca3d3595423e5c8b9004ec0d5d215
+  metadata.gz: 4f73b4928035cb3e6246f61ca7d40ce166263b7cbf0543f8d2075cf8b13dcd5db49bc060595a0cb8fbaf68c52dcfe679d829e60e3b304977c0d043d925afe5d8
+  data.tar.gz: dba22fde477a7032467f84310d102d315172df9a6e708d278fb16105128a0856294c420eee94c60f33d3df05760f0a63e9240e0407005d1431edebc4b24b961f

data/CHANGELOG.md

@@ -1,6 +1,6 @@
 # v1.9
 
-## Unreleased
+## Release v1.9.0 - 2020/01/22
 
 ### New feature
 
@@ -17,17 +17,25 @@
   https://github.com/fluent/fluentd/pull/2670
 * Support Ruby's Time class in msgpack serde
   https://github.com/fluent/fluentd/pull/2775
-* Clean up code
+* Clean up code/test
   https://github.com/fluent/fluentd/pull/2753
   https://github.com/fluent/fluentd/pull/2763
   https://github.com/fluent/fluentd/pull/2764
+  https://github.com/fluent/fluentd/pull/2780
 
-### Bug fixes
+### Bug fix
 
+* buffer: Disable the optimization of Metadata instance comparison on Windows
+  https://github.com/fluent/fluentd/pull/2778
 * outut/buffer: Fix stage size computation
   https://github.com/fluent/fluentd/pull/2734
 * server: Ignore Errno::EHOSTUNREACH in TLS accept to avoid fluentd restart
   https://github.com/fluent/fluentd/pull/2773
+* server: Fix IPv6 dual stack mode issue for udp socket
+  https://github.com/fluent/fluentd/pull/2781
+* config: Support @include/include directive for spaces included path
+  https://github.com/fluent/fluentd/pull/2780
+
 
 # v1.8
 

data/lib/fluent/config/v1_parser.rb

@@ -147,11 +147,13 @@ module Fluent
       end
 
       def eval_include(attrs, elems, uri)
-        u = URI.parse(uri)
-        if u.scheme == 'file' || (!u.scheme.nil? && u.scheme.length == 1) || u.path == uri # file path
+        # replace space(s)(' ') with '+' to prevent invalid uri due to space(s).
+        # See: https://github.com/fluent/fluentd/pull/2780#issuecomment-576081212
+        u = URI.parse(uri.gsub(/ /, '+'))
+        if u.scheme == 'file' || (!u.scheme.nil? && u.scheme.length == 1) || u.path == uri.gsub(/ /, '+') # file path
           # When the Windows absolute path then u.scheme.length == 1
           # e.g. C:
-          path = u.path
+          path = URI.decode_www_form_component(u.path)
           if path[0] != ?/
             pattern = File.expand_path("#{@include_basepath}/#{path}")
           else

data/lib/fluent/plugin/buffer.rb

@@ -138,9 +138,12 @@ module Fluent
         # Actually this overhead is very small but this class is generated *per chunk* (and used in hash object).
         # This means that this class is one of the most called object in Fluentd.
         # See https://github.com/fluent/fluentd/pull/2560
+        # But, this optimization has a side effect on Windows due to differing object_id.
+        # This difference causes flood of buffer files.
+        # So, this optimization should be enabled on non-Windows platform.
         def hash
           timekey.object_id
-        end
+        end unless Fluent.windows?
       end
 
       # for tests

data/lib/fluent/plugin_helper/server.rb

@@ -370,10 +370,10 @@ module Fluent
         sock = if shared
                  server_socket_manager_client.listen_udp(bind, port)
                else
-                 family = IPAddr.new(IPSocket.getaddress(bind)).ipv4? ? ::Socket::AF_INET : ::Socket::AF_INET6
-                 usock = UDPSocket.new(family)
-                 usock.bind(bind, port)
-                 usock
+                 # UDPSocket.new doesn't set IPV6_V6ONLY flag, so use Addrinfo class instead.
+                 usock = Addrinfo.udp(bind, port).bind
+                 usock.autoclose = false
+                 UDPSocket.for_fd(usock.fileno)
                end
         # close-on-exec is set by default in Ruby 2.0 or later (, and it's unavailable on Windows)
         sock.fcntl(Fcntl::F_SETFL, Fcntl::O_NONBLOCK) # nonblock

data/lib/fluent/version.rb

@@ -16,6 +16,6 @@
 
 module Fluent
 
-  VERSION = '1.9.0.rc2'
+  VERSION = '1.9.0'
 
 end

data/test/config/test_config_parser.rb

@@ -362,55 +362,56 @@ module Fluent::Config
     # port from test_config.rb
     sub_test_case '@include parsing' do
       TMP_DIR = File.dirname(__FILE__) + "/tmp/v1_config#{ENV['TEST_ENV_NUMBER']}"
+      TMP_DIR_WITH_SPACES = File.dirname(__FILE__) + "/tmp/folder with spaces/v1_config#{ENV['TEST_ENV_NUMBER']}"
 
       def write_config(path, data)
         FileUtils.mkdir_p(File.dirname(path))
         File.open(path, "w") { |f| f.write data }
       end
 
-      def prepare_config
-        write_config "#{TMP_DIR}/config_test_1.conf", %[
+      def prepare_config(tmp_dir)
+        write_config "#{tmp_dir}/config_test_1.conf", %[
         k1 root_config
         include dir/config_test_2.conf  #
-        @include #{TMP_DIR}/config_test_4.conf
-        include file://#{TMP_DIR}/config_test_5.conf
+        @include #{tmp_dir}/config_test_4.conf
+        include file://#{tmp_dir}/config_test_5.conf
         @include config.d/*.conf
       ]
-        write_config "#{TMP_DIR}/dir/config_test_2.conf", %[
+        write_config "#{tmp_dir}/dir/config_test_2.conf", %[
         k2 relative_path_include
         @include ../config_test_3.conf
       ]
-        write_config "#{TMP_DIR}/config_test_3.conf", %[
+        write_config "#{tmp_dir}/config_test_3.conf", %[
         k3 relative_include_in_included_file
       ]
-        write_config "#{TMP_DIR}/config_test_4.conf", %[
+        write_config "#{tmp_dir}/config_test_4.conf", %[
         k4 absolute_path_include
       ]
-        write_config "#{TMP_DIR}/config_test_5.conf", %[
+        write_config "#{tmp_dir}/config_test_5.conf", %[
         k5 uri_include
       ]
-        write_config "#{TMP_DIR}/config.d/config_test_6.conf", %[
+        write_config "#{tmp_dir}/config.d/config_test_6.conf", %[
         k6 wildcard_include_1
         <elem1 name>
           include normal_parameter
         </elem1>
       ]
-        write_config "#{TMP_DIR}/config.d/config_test_7.conf", %[
+        write_config "#{tmp_dir}/config.d/config_test_7.conf", %[
         k7 wildcard_include_2
       ]
-        write_config "#{TMP_DIR}/config.d/config_test_8.conf", %[
+        write_config "#{tmp_dir}/config.d/config_test_8.conf", %[
         <elem2 name>
           @include ../dir/config_test_9.conf
         </elem2>
       ]
-        write_config "#{TMP_DIR}/dir/config_test_9.conf", %[
+        write_config "#{tmp_dir}/dir/config_test_9.conf", %[
         k9 embedded
         <elem3 name>
           nested nested_value
           include hoge
         </elem3>
       ]
-        write_config "#{TMP_DIR}/config.d/00_config_test_8.conf", %[
+        write_config "#{tmp_dir}/config.d/00_config_test_8.conf", %[
         k8 wildcard_include_3
         <elem4 name>
           include normal_parameter
@@ -418,9 +419,11 @@ module Fluent::Config
       ]
       end
 
-      test 'parses @include / include correctly' do
-        prepare_config
-        c = read_config("#{TMP_DIR}/config_test_1.conf")
+      data("TMP_DIR without spaces" => TMP_DIR,
+           "TMP_DIR with spaces" => TMP_DIR_WITH_SPACES)
+      test 'parses @include / include correctly' do |data|
+        prepare_config(data)
+        c = read_config("#{data}/config_test_1.conf")
         assert_equal('root_config', c['k1'])
         assert_equal('relative_path_include', c['k2'])
         assert_equal('relative_include_in_included_file', c['k3'])

data/test/plugin/test_in_exec.rb

@@ -28,7 +28,7 @@ class ExecInputTest < Test::Unit::TestCase
 
   TSV_CONFIG = %[
     command ruby #{SCRIPT_PATH} "#{TEST_TIME}" 0
-    run_interval 1s
+    run_interval 0.3
     <parse>
       @type tsv
       keys time, tag, k1
@@ -43,7 +43,7 @@ class ExecInputTest < Test::Unit::TestCase
 
   JSON_CONFIG = %[
     command ruby #{SCRIPT_PATH} #{TEST_UNIX_TIME.to_i} 1
-    run_interval 1s
+    run_interval 0.3
     <parse>
       @type json
     </parse>
@@ -56,7 +56,7 @@ class ExecInputTest < Test::Unit::TestCase
 
   MSGPACK_CONFIG = %[
     command ruby #{SCRIPT_PATH} #{TEST_UNIX_TIME.to_i} 2
-    run_interval 1s
+    run_interval 0.3
     <parse>
       @type msgpack
     </parse>
@@ -70,7 +70,7 @@ class ExecInputTest < Test::Unit::TestCase
   # here document for not de-quoting backslashes
   REGEXP_CONFIG = %[
     command ruby #{SCRIPT_PATH} "#{TEST_TIME}" 3
-    run_interval 1s
+    run_interval 0.3
     tag regex_tag
 ] + <<'EOC'
     <parse>
@@ -143,7 +143,7 @@ EOC
       time_key time
       tag_key tag
       time_format %Y-%m-%d %H:%M:%S
-      run_interval 1s
+      run_interval 0.3
   ]
 
   JSON_CONFIG_COMPAT = %[
@@ -151,7 +151,7 @@ EOC
       format json
       tag_key tag
       time_key time
-      run_interval 1s
+      run_interval 0.3
   ]
 
   MSGPACK_CONFIG_COMPAT = %[
@@ -159,14 +159,14 @@ EOC
       format msgpack
       tag_key tagger
       time_key datetime
-      run_interval 1s
+      run_interval 0.3
   ]
 
   REGEXP_CONFIG_COMPAT = %[
       command ruby #{SCRIPT_PATH} "#{TEST_TIME}" 3
       format /(?<time>[^\\\]]*) (?<message>[^ ]*)/
       tag regex_tag
-      run_interval 1s
+      run_interval 0.3
   ]
 
   sub_test_case 'with traditional configuration' do
@@ -235,7 +235,7 @@ EOC
     d.run(expect_emits: 2, timeout: 10)
 
     assert{ d.events.length > 0 }
-    d.events.each_with_index {|event, i|
+    d.events.each {|event|
       assert_equal_event_time(time, event[1])
       assert_equal [tag, time, record], event
     }

data/test/plugin/test_in_forward.rb

@@ -231,10 +231,9 @@ class ForwardInputTest < Test::Unit::TestCase
         ["tag2", time_i, {"a"=>2}],
       ]
 
-      d.run(expect_records: records.length, timeout: 20) do
+      d.run(expect_records: records.length, timeout: 20, shutdown: true) do
         records.each {|tag, _time, record|
           send_data [tag, _time, record].to_json + "\n"
-        sleep 1
         }
       end
 
@@ -727,7 +726,7 @@ class ForwardInputTest < Test::Unit::TestCase
         events.each {|tag, _time, record|
           op = { 'chunk' => Base64.encode64(record.object_id.to_s) }
           expected_acks << op['chunk']
-          send_data [tag, _time, record, op].to_msgpack, try_to_receive_response: true, **options
+          send_data([tag, _time, record, op].to_msgpack, try_to_receive_response: true, response_timeout: 1, **options)
         }
       end
 
@@ -769,7 +768,7 @@ class ForwardInputTest < Test::Unit::TestCase
         }
         op = { 'chunk' => Base64.encode64(entries.object_id.to_s) }
         expected_acks << op['chunk']
-        send_data ["tag1", entries, op].to_msgpack, try_to_receive_response: true, **options
+        send_data(["tag1", entries, op].to_msgpack, try_to_receive_response: true, response_timeout: 1, **options)
       end
 
       assert_equal events, d.events
@@ -809,7 +808,7 @@ class ForwardInputTest < Test::Unit::TestCase
         }
         op = { 'chunk' => Base64.encode64(entries.object_id.to_s) }
         expected_acks << op['chunk']
-        send_data ["tag1", entries, op].to_msgpack, try_to_receive_response: true, **options
+        send_data(["tag1", entries, op].to_msgpack, try_to_receive_response: true, response_timeout: 1, **options)
       end
 
       assert_equal events, d.events
@@ -849,7 +848,7 @@ class ForwardInputTest < Test::Unit::TestCase
         events.each {|tag, _time, record|
           op = { 'chunk' => Base64.encode64(record.object_id.to_s) }
           expected_acks << op['chunk']
-          send_data [tag, _time, record, op].to_json, try_to_receive_response: true, **options
+          send_data([tag, _time, record, op].to_json, try_to_receive_response: true, response_timeout: 1, **options)
         }
       end
 
@@ -885,7 +884,7 @@ class ForwardInputTest < Test::Unit::TestCase
 
       d.run(expect_records: events.size, timeout: 20) do
         events.each {|tag, _time, record|
-          send_data [tag, _time, record].to_msgpack, try_to_receive_response: true, **options
+          send_data([tag, _time, record].to_msgpack, try_to_receive_response: true, response_timeout: 1, **options)
         }
       end
 
@@ -922,7 +921,7 @@ class ForwardInputTest < Test::Unit::TestCase
         events.each {|tag, _time, record|
           entries << [_time, record]
         }
-        send_data ["tag1", entries].to_msgpack, try_to_receive_response: true, **options
+        send_data(["tag1", entries].to_msgpack, try_to_receive_response: true, response_timeout: 1, **options)
       end
 
       assert_equal events, d.events
@@ -958,7 +957,7 @@ class ForwardInputTest < Test::Unit::TestCase
         events.each {|tag, _time, record|
           [_time, record].to_msgpack(entries)
         }
-        send_data ["tag1", entries].to_msgpack, try_to_receive_response: true, **options
+        send_data(["tag1", entries].to_msgpack, try_to_receive_response: true, response_timeout: 1, **options)
       end
 
       assert_equal events, d.events
@@ -994,7 +993,7 @@ class ForwardInputTest < Test::Unit::TestCase
 
       d.run(expect_records: events.size, timeout: 20) do
         events.each {|tag, _time, record|
-          send_data [tag, _time, record].to_json, try_to_receive_response: true, **options
+          send_data([tag, _time, record].to_json, try_to_receive_response: true, response_timeout: 1, **options)
         }
       end
 
@@ -1016,7 +1015,7 @@ class ForwardInputTest < Test::Unit::TestCase
   # nil: socket read timeout
   def read_data(io, timeout, &block)
     res = ''
-    select_timeout = 2
+    select_timeout = 0.5
     clock_id = Process::CLOCK_MONOTONIC_RAW rescue Process::CLOCK_MONOTONIC
     timeout_at = Process.clock_gettime(clock_id) + timeout
     begin

data/test/plugin/test_in_object_space.rb

@@ -27,7 +27,7 @@ class ObjectSpaceInputTest < Test::Unit::TestCase
   end
 
   TESTCONFIG = %[
-    emit_interval 1
+    emit_interval 0.2
     tag t1
     top 2
   ]
@@ -38,7 +38,7 @@ class ObjectSpaceInputTest < Test::Unit::TestCase
 
   def test_configure
     d = create_driver
-    assert_equal 1, d.instance.emit_interval
+    assert_equal 0.2, d.instance.emit_interval
     assert_equal "t1", d.instance.tag
     assert_equal 2, d.instance.top
   end
@@ -46,11 +46,7 @@ class ObjectSpaceInputTest < Test::Unit::TestCase
   def test_emit
     d = create_driver
 
-    d.run do
-      waiting(10, d.instance) do
-        sleep 0.5 until d.events.size > 3
-      end
-    end
+    d.run(expect_emits: 3)
 
     emits = d.events
     assert{ emits.length > 0 }

data/test/plugin/test_out_exec_filter.rb

@@ -460,7 +460,7 @@ class ExecFilterOutputTest < Test::Unit::TestCase
 
   CONFIG_ROUND_ROBIN = %[
     command ruby -e 'STDOUT.sync = true; STDIN.each_line{|line| puts line.chomp + "\t" + Process.pid.to_s }'
-    num_children 3
+    num_children 2
     <inject>
       tag_key     tag
       time_key    time_in
@@ -489,7 +489,7 @@ class ExecFilterOutputTest < Test::Unit::TestCase
     out_time_key time_out
     time_format %Y-%m-%d %H:%M:%S
     localtime
-    num_children 3
+    num_children 2
   ]
 
   data(
@@ -498,53 +498,38 @@ class ExecFilterOutputTest < Test::Unit::TestCase
   )
   test 'using child processes by round robin' do |conf|
     d = create_driver(conf)
-    time = event_time("2011-01-02 13:14:15")
+    time = event_time('2011-01-02 13:14:15')
 
-    d.run(default_tag: 'test', expect_emits: 1, timeout: 10, start: true,  shutdown: false){ d.feed(time, {"k1"=>1}) }
-    d.run(default_tag: 'test', expect_emits: 1, timeout: 10, start: false, shutdown: false){ d.feed(time, {"k1"=>2}) }
-    d.run(default_tag: 'test', expect_emits: 1, timeout: 10, start: false, shutdown: false){ d.feed(time, {"k1"=>3}) }
-    d.run(default_tag: 'test', expect_emits: 1, timeout: 10, start: false, shutdown: false){ d.feed(time, {"k1"=>4}) }
-    d.run(default_tag: 'test', expect_emits: 1, timeout: 10, start: false, shutdown: false){ d.feed(time, {"k1"=>5}) }
-    d.run(default_tag: 'test', expect_emits: 1, timeout: 10, start: false, shutdown: false){ d.feed(time, {"k1"=>6}) }
-    d.run(default_tag: 'test', expect_emits: 1, timeout: 10, start: false, shutdown: false){ d.feed(time, {"k1"=>7}) }
-    d.run(default_tag: 'test', expect_emits: 1, timeout: 10, start: false, shutdown: false){ d.feed(time, {"k1"=>8}) }
-    d.run(default_tag: 'test', expect_emits: 1, timeout: 10, start: false, shutdown: true ){ d.feed(time, {"k1"=>9}) }
+    d.run(default_tag: 'test', expect_emits: 1, timeout: 10, start: true,  shutdown: false){ d.feed(time, {"k1" => 0}) }
+    d.run(default_tag: 'test', expect_emits: 1, timeout: 10, start: false, shutdown: false){ d.feed(time, {"k1" => 1}) }
+    d.run(default_tag: 'test', expect_emits: 1, timeout: 10, start: false, shutdown: false){ d.feed(time, {"k1" => 2}) }
+    d.run(default_tag: 'test', expect_emits: 1, timeout: 10, start: false, shutdown: false){ d.feed(time, {"k1" => 3}) }
 
-    assert_equal "2011-01-02 13:14:15\ttest\t1\n", d.formatted[0]
-    assert_equal "2011-01-02 13:14:15\ttest\t2\n", d.formatted[1]
-    assert_equal "2011-01-02 13:14:15\ttest\t3\n", d.formatted[2]
-    assert_equal "2011-01-02 13:14:15\ttest\t4\n", d.formatted[3]
-    assert_equal "2011-01-02 13:14:15\ttest\t5\n", d.formatted[4]
-    assert_equal "2011-01-02 13:14:15\ttest\t6\n", d.formatted[5]
-    assert_equal "2011-01-02 13:14:15\ttest\t7\n", d.formatted[6]
-    assert_equal "2011-01-02 13:14:15\ttest\t8\n", d.formatted[7]
-    assert_equal "2011-01-02 13:14:15\ttest\t9\n", d.formatted[8]
+    assert_equal "2011-01-02 13:14:15\ttest\t0\n", d.formatted[0]
+    assert_equal "2011-01-02 13:14:15\ttest\t1\n", d.formatted[1]
+    assert_equal "2011-01-02 13:14:15\ttest\t2\n", d.formatted[2]
+    assert_equal "2011-01-02 13:14:15\ttest\t3\n", d.formatted[3]
 
     events = d.events
-    assert_equal 9, events.length
+    assert_equal 4, events.length
 
     pid_list = []
     events.each do |event|
       pid = event[2]['child_pid']
       pid_list << pid unless pid_list.include?(pid)
     end
-    assert_equal 3, pid_list.size, "the number of pids should be same with number of child processes: #{pid_list.inspect}"
+    assert_equal 2, pid_list.size, "the number of pids should be same with number of child processes: #{pid_list.inspect}"
 
     assert_equal pid_list[0], events[0][2]['child_pid']
     assert_equal pid_list[1], events[1][2]['child_pid']
-    assert_equal pid_list[2], events[2][2]['child_pid']
-    assert_equal pid_list[0], events[3][2]['child_pid']
-    assert_equal pid_list[1], events[4][2]['child_pid']
-    assert_equal pid_list[2], events[5][2]['child_pid']
-    assert_equal pid_list[0], events[6][2]['child_pid']
-    assert_equal pid_list[1], events[7][2]['child_pid']
-    assert_equal pid_list[2], events[8][2]['child_pid']
+    assert_equal pid_list[0], events[2][2]['child_pid']
+    assert_equal pid_list[1], events[3][2]['child_pid']
   end
 
   # child process exits per 3 lines
   CONFIG_RESPAWN = %[
     command ruby -e 'STDOUT.sync = true; proc = ->(){line = STDIN.readline.chomp; puts line + "\t" + Process.pid.to_s}; proc.call; proc.call; proc.call'
-    num_children 4
+    num_children 2
     child_respawn -1
     <inject>
       tag_key   tag
@@ -566,7 +551,7 @@ class ExecFilterOutputTest < Test::Unit::TestCase
 
   CONFIG_RESPAWN_COMPAT = %[
     command ruby -e 'STDOUT.sync = true; proc = ->(){line = STDIN.readline.chomp; puts line + "\t" + Process.pid.to_s}; proc.call; proc.call; proc.call'
-    num_children 4
+    num_children 2
     child_respawn -1
     in_keys time_in,tag,k1
     out_keys time_out,tag,k2,child_pid
@@ -584,35 +569,33 @@ class ExecFilterOutputTest < Test::Unit::TestCase
   test 'emit events via child processes which exits sometimes' do |conf|
     d = create_driver(conf)
     time = event_time("2011-01-02 13:14:15")
-
     countup = 0
 
     d.run(start: true, shutdown: false)
+    assert_equal 2, d.instance.instance_eval{ @_child_process_processes.size }
 
-    assert_equal 4, d.instance.instance_eval{ @_child_process_processes.size }
-
-    20.times do
-      d.run(default_tag: 'test', expect_emits: 1, timeout: 10, force_flush_retry: true, start: false, shutdown: false) do
-        d.feed(time, {"k1"=>countup}); countup += 1
-        d.feed(time, {"k1"=>countup}); countup += 1
-        d.feed(time, {"k1"=>countup}); countup += 1
+    2.times do
+      d.run(default_tag: 'test', expect_emits: 3, timeout: 3, force_flush_retry: true, start: false, shutdown: false) do
+        d.feed(time, { "k1" => countup }); countup += 1
+        d.feed(time, { "k1" => countup }); countup += 1
+        d.feed(time, { "k1" => countup }); countup += 1
       end
     end
 
     events = d.events
-    assert_equal 60, events.length
+    assert_equal 6, events.length
 
     pid_list = []
     events.each do |event|
       pid = event[2]['child_pid']
       pid_list << pid unless pid_list.include?(pid)
     end
-    # the number of pids should be same with number of child processes
-    assert{ pid_list.size >= 18 }
 
+    # the number of pids should be same with number of child processes
+    assert_equal 2, pid_list.size
     logs = d.instance.log.out.logs
-    assert{ logs.select{|l| l.include?("child process exits with error code") }.size >= 18 } # 20
-    assert{ logs.select{|l| l.include?("respawning child process") }.size >= 18 } # 20
+    assert_equal 2, logs.select { |l| l.include?('child process exits with error code') }.size
+    assert_equal 2, logs.select { |l| l.include?('respawning child process') }.size
 
     d.run(start: false, shutdown: true)
   end

data/test/plugin/test_out_forward.rb

@@ -671,7 +671,7 @@ EOL
 
     @d = d = create_driver(CONFIG + %[
       require_ack_response true
-      ack_response_timeout 5s
+      ack_response_timeout 1s
       <buffer tag>
         flush_mode immediate
         retry_type periodic
@@ -699,7 +699,7 @@ EOL
       end
     end
 
-    assert_equal (5 + 2), delayed_commit_timeout_value
+    assert_equal (1 + 2), delayed_commit_timeout_value
 
     events = target_input_driver.events
     assert_equal ['test', time, records[0]], events[0]

data/test/plugin/test_output_as_buffered.rb

@@ -699,7 +699,7 @@ class BufferedOutputTest < Test::Unit::TestCase
         r["key#{i}"] = "value #{i}"
       end
 
-      3.times do |i|
+      2.times do |i|
         rand_records = rand(1..4)
         es = Fluent::ArrayEventStream.new([ [t, r] ] * rand_records)
         assert_equal rand_records, es.size

data/test/plugin/test_output_as_buffered_overflow.rb

@@ -141,7 +141,7 @@ class BufferedOutputOverflowTest < Test::Unit::TestCase
       assert !@i.buffer.storable?
 
       Thread.new do
-        sleep 3
+        sleep 1
         failing = false
       end
 

data/test/plugin_helper/test_child_process.rb

@@ -232,30 +232,26 @@ class ChildProcessTest < Test::Unit::TestCase
   end
 
   test 'can execute external command at just once, which runs forever' do
-    m = Mutex.new
     ary = []
     Timeout.timeout(TEST_DEADLOCK_TIMEOUT) do
       ran = false
-      args = ["-e", "while sleep #{TEST_WAIT_INTERVAL_FOR_LOOP}; puts 1; STDOUT.flush; end"]
+      args = ["-e", "while sleep 0.1; puts 1; STDOUT.flush; end"]
       @d.child_process_execute(:t3, "ruby", arguments: args, mode: [:read]) do |io|
-        m.lock
-        ran = true
         begin
           while @d.child_process_running? && line = io.readline
+            ran ||= true
             ary << line
           end
         rescue
           # ignore
-        ensure
-          m.unlock
         end
       end
-      sleep TEST_WAIT_INTERVAL_FOR_BLOCK_RUNNING until m.locked? || ran
-      sleep TEST_WAIT_INTERVAL_FOR_LOOP * 10
+      sleep TEST_WAIT_INTERVAL_FOR_BLOCK_RUNNING until ran
+      sleep 1
+
       @d.stop # nothing occurs
       @d.shutdown
-
-      assert{ ary.size > 5 }
+      assert { ary.size >= 4 }
 
       @d.close
 
@@ -272,7 +268,7 @@ class ChildProcessTest < Test::Unit::TestCase
     ary = []
     Timeout.timeout(TEST_DEADLOCK_TIMEOUT) do
       ran = false
-      @d.child_process_execute(:t4, "ruby -e 'Signal.trap(:TERM, nil); while sleep #{TEST_WAIT_INTERVAL_FOR_LOOP}; puts 1; STDOUT.flush rescue nil; end'", mode: [:read]) do |io|
+      @d.child_process_execute(:t4, "ruby -e 'Signal.trap(:TERM, nil); while sleep 0.1; puts 1; STDOUT.flush rescue nil; end'", mode: [:read]) do |io|
         m.lock
         ran = true
         begin
@@ -290,17 +286,17 @@ class ChildProcessTest < Test::Unit::TestCase
       assert_equal [], @d.log.out.logs
 
       @d.stop # nothing occurs
-      sleep TEST_WAIT_INTERVAL_FOR_LOOP * 5
+      sleep TEST_WAIT_INTERVAL_FOR_LOOP
       lines1 = ary.size
       assert{ lines1 > 1 }
 
       pid = @d._child_process_processes.keys.first
-
+      # default value 10 is too long for test
+      @d.instance_eval { @_child_process_exit_timeout = 1 }
       @d.shutdown
-      sleep TEST_WAIT_INTERVAL_FOR_LOOP * 5
+      sleep TEST_WAIT_INTERVAL_FOR_LOOP
       lines2 = ary.size
-      assert{ lines2 > lines1 }
-
+      assert { lines2 > lines1 }
       @d.close
 
       assert_nil((Process.waitpid(pid, Process::WNOHANG) rescue nil))
@@ -318,12 +314,12 @@ class ChildProcessTest < Test::Unit::TestCase
 
   test 'can execute external command many times, which finishes immediately' do
     ary = []
-    arguments = ["-e", "3.times{ puts 'okay'; STDOUT.flush rescue nil; sleep #{TEST_WAIT_INTERVAL_FOR_LOOP} }"] # 0.5 * 3
+    arguments = ["-e", "puts 'okay'; STDOUT.flush rescue nil"]
     Timeout.timeout(TEST_DEADLOCK_TIMEOUT) do
-      @d.child_process_execute(:t5, "ruby", arguments: arguments, interval: 5, mode: [:read]) do |io|
+      @d.child_process_execute(:t5, "ruby", arguments: arguments, interval: 1, mode: [:read]) do |io|
         ary << io.read.split("\n").map(&:chomp).join
       end
-      sleep 13 # 5sec * 2 + 3sec
+      sleep 2.5 # 2sec(second invocation) + 0.5sec
       assert_equal [], @d.log.out.logs
       @d.stop
       assert_equal [], @d.log.out.logs
@@ -334,13 +330,12 @@ class ChildProcessTest < Test::Unit::TestCase
 
   test 'can execute external command many times, with leading once executed immediately' do
     ary = []
-    arguments = ["-e", "3.times{ puts 'okay'; STDOUT.flush rescue nil; sleep #{TEST_WAIT_INTERVAL_FOR_LOOP} }"]
+    arguments = ["-e", "puts 'okay'; STDOUT.flush rescue nil"]
     Timeout.timeout(TEST_DEADLOCK_TIMEOUT) do
-      @d.child_process_execute(:t6, "ruby", arguments: arguments, interval: 5, immediate: true, mode: [:read]) do |io|
+      @d.child_process_execute(:t6, "ruby", arguments: arguments, interval: 1, immediate: true, mode: [:read]) do |io|
         ary << io.read.split("\n").map(&:chomp).join
       end
-      sleep 8 # 5sec * 1 + 3sec
-              # but expected lines are same with test above
+      sleep 1.5 # 2sec(second invocation) + 0.5sec
       @d.stop; @d.shutdown; @d.close; @d.terminate
       assert_equal 2, ary.size
       assert_equal [], @d.log.out.logs
@@ -349,7 +344,7 @@ class ChildProcessTest < Test::Unit::TestCase
 
   test 'does not execute long running external command in parallel in default' do
     ary = []
-    arguments = ["-e", "10.times{ puts 'okay'; STDOUT.flush rescue nil; sleep #{TEST_WAIT_INTERVAL_FOR_LOOP} }"] # 0.5 * 10
+    arguments = ["-e", "10.times{ sleep #{TEST_WAIT_INTERVAL_FOR_LOOP} }"] # 5 sec
     Timeout.timeout(TEST_DEADLOCK_TIMEOUT) do
       assert_equal [], @d.log.out.logs
       @d.log.out.singleton_class.module_eval do
@@ -359,13 +354,13 @@ class ChildProcessTest < Test::Unit::TestCase
         }
       end
 
-      @d.child_process_execute(:t7, "ruby", arguments: arguments, interval: 2, immediate: true, mode: [:read]) do |io|
+      @d.child_process_execute(:t7, "ruby", arguments: arguments, interval: 1, immediate: true, mode: [:read]) do |io|
         ary << io.read.split("\n").map(&:chomp).join
       end
-      sleep 4
+      sleep 2
       assert_equal 1, @d._child_process_processes.size
       @d.stop
-      warn_msg = '[warn]: previous child process is still running. skipped. title=:t7 command="ruby" arguments=["-e", "10.times{ puts \'okay\'; STDOUT.flush rescue nil; sleep 0.5 }"] interval=2 parallel=false' + "\n"
+      warn_msg = '[warn]: previous child process is still running. skipped. title=:t7 command="ruby" arguments=["-e", "10.times{ sleep 0.5 }"] interval=1 parallel=false' + "\n"
       logs = @d.log.out.logs
       assert{ logs.first.end_with?(warn_msg) }
       assert{ logs.all?{|line| line.end_with?(warn_msg) } }
@@ -376,14 +371,14 @@ class ChildProcessTest < Test::Unit::TestCase
 
   test 'can execute long running external command in parallel if specified' do
     ary = []
-    arguments = ["-e", "10.times{ puts 'okay'; STDOUT.flush rescue nil; sleep #{TEST_WAIT_INTERVAL_FOR_LOOP} }"] # 0.5 * 10 sec
+    arguments = ["-e", "10.times{  puts 'okay'; STDOUT.flush rescue nil; sleep #{TEST_WAIT_INTERVAL_FOR_LOOP} }"] # 5 sec
     Timeout.timeout(TEST_DEADLOCK_TIMEOUT) do
       @d.child_process_execute(:t8, "ruby", arguments: arguments, interval: 1, immediate: true, parallel: true, mode: [:read]) do |io|
         ary << io.read.split("\n").map(&:chomp).join
       end
-      sleep 4
+      sleep 2
       processes = @d._child_process_processes.size
-      assert{ processes >= 3 && processes <= 5 }
+      assert { processes >= 2 && processes <= 4 }
       @d.stop; @d.shutdown; @d.close; @d.terminate
       assert_equal [], @d.log.out.logs
     end
@@ -662,14 +657,14 @@ class ChildProcessTest < Test::Unit::TestCase
       block_exits = false
       callback_called = false
       exit_status = nil
-      args = ['-e', 'sleep ARGV[0].to_i; puts "yay"; File.unlink ARGV[1]', '1', @temp_path]
+      args = ['-e', 'puts "yay"; File.unlink ARGV[0]', @temp_path]
       cb = ->(status){ exit_status = status; callback_called = true }
 
       str = nil
-
       pid = nil
       @d.child_process_execute(:st1, "ruby", arguments: args, mode: [:read], on_exit_callback: cb) do |readio|
-        pid = @d.instance_eval{ child_process_id }
+        assert !callback_called # ensure yet to be called
+        pid = @d.instance_eval { child_process_id }
         str = readio.read.chomp
         block_exits = true
       end
@@ -697,16 +692,11 @@ class ChildProcessTest < Test::Unit::TestCase
       cb = ->(status){ exit_status = status; callback_called = true }
 
       str = nil
-
       pid = nil
       @d.child_process_execute(:st1, "ruby", arguments: args, mode: [:read], on_exit_callback: cb) do |readio|
-        pid = @d.instance_eval{ child_process_id }
-        sleep 10 # to run child process correctly
-        Process.kill(:QUIT, pid)
+        pid = @d.instance_eval { child_process_id }
         sleep 1
-        Process.kill(:QUIT, pid) rescue nil # once more to send kill
-        sleep 1
-        Process.kill(:QUIT, pid) rescue nil # just like sync
+        Process.kill(:QUIT, pid)
         str = readio.read.chomp rescue nil # empty string before EOF
         block_exits = true
       end
@@ -717,29 +707,28 @@ class ChildProcessTest < Test::Unit::TestCase
       assert callback_called
       assert exit_status
 
-      # This test sometimes fails on TravisCI
-      #    with [nil, 11] # SIGSEGV
-      # or with [1, nil]  # ???
-      assert_equal [nil, 3, true, ""], [exit_status.exitstatus, exit_status.termsig, File.exist?(@temp_path), str] # SIGQUIT
-      # SIGSEGV looks a kind of BUG of ruby...
+      assert_equal nil, exit_status.exitstatus
+      assert_equal 3, exit_status.termsig
+      assert File.exist?(@temp_path)
+      assert_equal '', str
     end
 
     test 'calls on_exit_callback for each process exits for interval call using on_exit_callback' do
       read_data_list = []
       exit_status_list = []
 
-      args = ['-e', 'puts "yay"', '1']
+      args = ['-e', 'puts "yay"']
       cb = ->(status){ exit_status_list << status }
 
       Timeout.timeout(TEST_DEADLOCK_TIMEOUT) do
-        @d.child_process_execute(:st1, "ruby", arguments: args, immediate: true, interval: 2, mode: [:read], on_exit_callback: cb) do |readio|
+        @d.child_process_execute(:st1, "ruby", arguments: args, immediate: true, interval: 1, mode: [:read], on_exit_callback: cb) do |readio|
           read_data_list << readio.read.chomp
         end
-        sleep 10
+        sleep 2
       end
 
-      assert{ read_data_list.size >= 3 }
-      assert{ exit_status_list.size >= 3 }
+      assert { read_data_list.size >= 2 }
+      assert { exit_status_list.size >= 2 }
     end
 
     test 'waits lasting child process until wait_timeout if block is not specified' do
@@ -747,11 +736,11 @@ class ChildProcessTest < Test::Unit::TestCase
 
       callback_called = false
       exit_status = nil
-      args = ['-e', 'sleep ARGV[0].to_i; File.unlink ARGV[1]', '1', @temp_path]
+      args = ['-e', 'File.unlink ARGV[0]', @temp_path]
       cb = ->(status){ exit_status = status; callback_called = true }
 
       Timeout.timeout(TEST_DEADLOCK_TIMEOUT) do
-        @d.child_process_execute(:t17, "ruby", arguments: args, on_exit_callback: cb, wait_timeout: 5)
+        @d.child_process_execute(:t17, "ruby", arguments: args, on_exit_callback: cb, wait_timeout: 2)
         sleep TEST_WAIT_INTERVAL_FOR_BLOCK_RUNNING until callback_called
       end
 
@@ -766,7 +755,7 @@ class ChildProcessTest < Test::Unit::TestCase
 
       callback_called = false
       exit_status = nil
-      args = ['-e', 'sleep ARGV[0].to_i; File.unlink ARGV[1]', '3', @temp_path]
+      args = ['-e', 'File.unlink ARGV[0]', @temp_path]
       cb = ->(status){ exit_status = status; callback_called = true }
 
       Timeout.timeout(TEST_DEADLOCK_TIMEOUT) do
@@ -791,7 +780,7 @@ class ChildProcessTest < Test::Unit::TestCase
       cb = ->(status){ exit_status = status; callback_called = true }
 
       Timeout.timeout(TEST_DEADLOCK_TIMEOUT) do
-        @d.child_process_execute(:t17, "ruby", arguments: args, on_exit_callback: cb, wait_timeout: 3)
+        @d.child_process_execute(:t17, "ruby", arguments: args, on_exit_callback: cb, wait_timeout: 1)
         sleep TEST_WAIT_INTERVAL_FOR_BLOCK_RUNNING until callback_called
       end
 
@@ -813,8 +802,8 @@ class ChildProcessTest < Test::Unit::TestCase
       cb = ->(status){ exit_status = status; callback_called = true }
 
       Timeout.timeout(TEST_DEADLOCK_TIMEOUT) do
-        @d.child_process_execute(:t17, "ruby", arguments: args, mode: nil, on_exit_callback: cb, wait_timeout: 3) do
-          sleep 3
+        @d.child_process_execute(:t17, "ruby", arguments: args, mode: nil, on_exit_callback: cb, wait_timeout: 1) do
+          sleep 1
         end
         sleep TEST_WAIT_INTERVAL_FOR_BLOCK_RUNNING until callback_called
       end

data/test/plugin_helper/test_server.rb

@@ -751,6 +751,19 @@ class ServerPluginHelperTest < Test::Unit::TestCase
       assert_equal 1, errors.size
       assert_equal "BUG: this event is disabled for udp: close", errors.first.message
     end
+
+    test 'can bind IPv4 / IPv6 together' do
+      omit "IPv6 unavailable here" unless ipv6_enabled?
+
+      assert_nothing_raised do
+        @d.server_create_udp(:s_ipv4_udp, PORT, bind: '0.0.0.0', shared: false, max_bytes: 128) do |data, sock|
+          # ...
+        end
+        @d.server_create_udp(:s_ipv6_udp, PORT, bind: '::', shared: false, max_bytes: 128) do |data, sock|
+          # ...
+        end
+      end
+    end
   end
 
   module CertUtil

data/test/plugin_helper/test_timer.rb

@@ -34,12 +34,12 @@ class TimerTest < Test::Unit::TestCase
       counter += 1
     end
 
-    sleep 5
+    sleep 2
 
     d1.stop
     assert !d1.timer_running?
 
-    assert{ counter >= 3 && counter <= 6 }
+    assert{ counter >= 1 && counter <= 2 }
 
     d1.shutdown; d1.close; d1.terminate
   end
@@ -52,19 +52,18 @@ class TimerTest < Test::Unit::TestCase
     counter1 = 0
     counter2 = 0
 
-    d1.timer_execute(:t1, 1) do
+    d1.timer_execute(:t1, 0.2) do
       counter1 += 1
     end
-    d1.timer_execute(:t2, 2) do
+    d1.timer_execute(:t2, 0.2) do
       counter2 += 1
     end
 
-    sleep 6
-
+    sleep 1
     d1.stop
 
-    assert{ counter1 >= 4 && counter1 <= 7 }
-    assert{ counter2 >= 2 && counter2 <= 4 }
+    assert{ counter1 >= 4 && counter1 <= 5 }
+    assert{ counter2 >= 4 && counter2 <= 5 }
 
     d1.shutdown; d1.close; d1.terminate
   end
@@ -77,19 +76,18 @@ class TimerTest < Test::Unit::TestCase
     counter1 = 0
     counter2 = 0
 
-    d1.timer_execute(:t1, 1) do
+    d1.timer_execute(:t1, 0.2) do
       counter1 += 1
     end
-    d1.timer_execute(:t2, 1) do
+    d1.timer_execute(:t2, 0.2) do
       raise "abort!!!!!!" if counter2 > 1
       counter2 += 1
     end
 
-    sleep 5
-
+    sleep 1
     d1.stop
 
-    assert{ counter1 >= 3 && counter1 <= 6 }
+    assert{ counter1 >= 4 && counter1 <= 5 }
     assert{ counter2 == 2 }
     msg = "Unexpected error raised. Stopping the timer. title=:t2"
     assert{ d1.log.out.logs.any?{|line| line.include?("[error]:") && line.include?(msg) && line.include?("abort!!!!!!") } }

data/test/test_supervisor.rb

@@ -176,6 +176,9 @@ class SupervisorTest < ::Test::Unit::TestCase
   log_level debug
 </system>
 ]
+    now = Time.now
+    Timecop.freeze(now)
+
     write_config tmp_dir, conf_info_str
 
     params = {}
@@ -208,7 +211,7 @@ class SupervisorTest < ::Test::Unit::TestCase
     assert_nil pre_config_mtime
     assert_nil pre_loadtime
 
-    sleep 5
+    Timecop.freeze(now + 5)
 
     # third call after 5 seconds(don't reuse config)
     se_config = load_config_proc.call
@@ -228,6 +231,8 @@ class SupervisorTest < ::Test::Unit::TestCase
     # fifth call after changed conf file(don't reuse config)
     se_config = load_config_proc.call
     assert_equal Fluent::Log::LEVEL_INFO, se_config[:log_level]
+  ensure
+    Timecop.return
   end
 
   def test_load_config_for_daemonize
@@ -242,6 +247,10 @@ class SupervisorTest < ::Test::Unit::TestCase
   log_level debug
 </system>
 ]
+
+    now = Time.now
+    Timecop.freeze(now)
+
     write_config tmp_dir, conf_info_str
 
     params = {}
@@ -275,9 +284,9 @@ class SupervisorTest < ::Test::Unit::TestCase
     assert_nil pre_config_mtime
     assert_nil pre_loadtime
 
-    sleep 5
+    Timecop.freeze(now + 5)
 
-    # third call after 5 seconds(don't reuse config)
+    # third call after 6 seconds(don't reuse config)
     se_config = load_config_proc.call
     pre_config_mtime = se_config[:windows_daemon_cmdline][5]['pre_config_mtime']
     pre_loadtime = se_config[:windows_daemon_cmdline][5]['pre_loadtime']
@@ -295,6 +304,8 @@ class SupervisorTest < ::Test::Unit::TestCase
     # fifth call after changed conf file(don't reuse config)
     se_config = load_config_proc.call
     assert_equal Fluent::Log::LEVEL_INFO, se_config[:log_level]
+  ensure
+    Timecop.return
   end
 
   def test_logger

data/test/test_test_drivers.rb

@@ -47,8 +47,8 @@ class TestDriverTest < ::Test::Unit::TestCase
       driver_class, plugin_class = args
       d = driver_class.new(Class.new(plugin_class))
       assert_raise Fluent::Test::Driver::TestTimedOut do
-        d.run(timeout: 1) do
-          sleep 5
+        d.run(timeout: 0.5) do
+          sleep 2
         end
       end
     end
@@ -67,7 +67,7 @@ class TestDriverTest < ::Test::Unit::TestCase
         assert_nothing_raised do
           before = Process.clock_gettime(Process::CLOCK_MONOTONIC)
           d.end_if{ false }
-          d.run(timeout: 5) do
+          d.run(timeout: 1) do
             sleep 0.1 until d.stop?
           end
           after = Process.clock_gettime(Process::CLOCK_MONOTONIC)
@@ -89,6 +89,7 @@ class TestDriverTest < ::Test::Unit::TestCase
           end
         end
       end
+
       assert_raise RuntimeError.new("yaaaaaaaaaay!") do
         d.end_if{ false }
         d.run(timeout: 3) do

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: fluentd
 version: !ruby/object:Gem::Version
-  version: 1.9.0.rc2
+  version: 1.9.0
 platform: ruby
 authors:
 - Sadayuki Furuhashi
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2020-01-15 00:00:00.000000000 Z
+date: 2020-01-22 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: msgpack
@@ -848,9 +848,9 @@ required_ruby_version: !ruby/object:Gem::Requirement
       version: '2.4'
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
-  - - ">"
+  - - ">="
     - !ruby/object:Gem::Version
-      version: 1.3.1
+      version: '0'
 requirements: []
 rubygems_version: 3.0.3
 signing_key: