fluentd 0.12.40 → 1.6.2

data/test/test_mixin.rb

@@ -208,7 +208,7 @@ module MixinTest
 
     def test_timezone_invalid
       assert_raise(Fluent::ConfigError) do
-        d = create_driver(Fluent::SetTimeKeyMixin, %[
+        create_driver(Fluent::SetTimeKeyMixin, %[
         include_time_key true
         timezone Invalid/Invalid
         ])

data/test/test_output.rb

@@ -1,8 +1,10 @@
 require_relative 'helper'
 require 'fluent/test'
 require 'fluent/output'
+require 'fluent/output_chain'
+require 'fluent/plugin/buffer'
 require 'timecop'
-require 'flexmock'
+require 'flexmock/test_unit'
 
 module FluentOutputTest
   include Fluent
@@ -15,6 +17,7 @@ module FluentOutputTest
       def startup
         $LOAD_PATH.unshift File.expand_path(File.join(File.dirname(__FILE__), 'scripts'))
         require 'fluent/plugin/out_test'
+        require 'fluent/plugin/out_test2'
       end
 
       def shutdown
@@ -47,7 +50,6 @@ module FluentOutputTest
       assert_equal nil, d.instance.max_retry_wait
       assert_equal 1.0, d.instance.retry_wait
       assert_equal 1, d.instance.num_threads
-      assert_equal 20.0, d.instance.slow_flush_log_threshold
       assert_equal 1, d.instance.queued_chunk_flush_interval
 
       # max_retry_wait
@@ -58,51 +60,24 @@ module FluentOutputTest
       d = create_driver(CONFIG + %[disable_retry_limit true])
       assert_equal true, d.instance.disable_retry_limit
 
-      # retry_wait is converted to Float for calc_retry_wait
-      d = create_driver(CONFIG + %[retry_wait 1s])
-      assert_equal Float, d.instance.retry_wait.class
+      #### retry_state cares it
+      # # retry_wait is converted to Float for calc_retry_wait
+      # d = create_driver(CONFIG + %[retry_wait 1s])
+      # assert_equal Float, d.instance.retry_wait.class
     end
 
-    def test_calc_retry_wait
-      # default
-      d = create_driver
-      d.instance.retry_limit.times {
-        # "d.instance.instance_variable_get(:@num_errors) += 1" causes SyntaxError
-        d.instance.instance_eval { @num_errors += 1 }
-      }
-      wait = d.instance.retry_wait * (2 ** (d.instance.retry_limit - 1))
-      assert( d.instance.calc_retry_wait > wait - wait / 8.0 )
-
-      # max_retry_wait
-      d = create_driver(CONFIG + %[max_retry_wait 4])
-      d.instance.retry_limit.times {
-        d.instance.instance_eval { @num_errors += 1 }
-      }
-      assert_equal 4, d.instance.calc_retry_wait
-    end
-
-    def test_calc_retry_wait_with_integer_retry_wait
-      d = create_driver(CONFIG + %[retry_wait 2s])
-      d.instance.retry_limit.times {
-        d.instance.instance_eval { @num_errors += 1 }
-      }
-      assert_equal true, d.instance.calc_retry_wait.finite?
+    class FormatterInjectTestOutput < Fluent::Output
+      def initialize
+        super
+        @formatter = nil
+      end
     end
-
-    def test_large_num_retries
-      # Test that everything works properly after a very large number of
-      # retries and we hit the expected max_retry_wait.
-      exp_max_retry_wait = 300
-      d = create_driver(CONFIG + %[
-        disable_retry_limit true
-        max_retry_wait #{exp_max_retry_wait}
-      ])
-      d.instance.instance_eval { @num_errors += 1000 }
-      assert_equal exp_max_retry_wait, d.instance.calc_retry_wait
-      d.instance.instance_eval { @num_errors += 1000 }
-      assert_equal exp_max_retry_wait, d.instance.calc_retry_wait
-      d.instance.instance_eval { @num_errors += 1000 }
-      assert_equal exp_max_retry_wait, d.instance.calc_retry_wait
+    def test_start
+      i = FormatterInjectTestOutput.new
+      i.configure(config_element('ROOT', '', {}, [config_element('inject', '', {'hostname_key' => "host"})]))
+      assert_nothing_raised do
+        i.start
+      end
     end
 
     def create_mock_driver(conf=CONFIG)
@@ -134,135 +109,63 @@ module FluentOutputTest
       end.configure(conf)
     end
 
-    def test_submit_flush_target
-      # default
-      d = create_mock_driver
-      d.instance.start_mock
-      assert_equal 0, d.instance.instance_variable_get('@writer_current_position')
-      d.instance.submit_flush
-      assert_equal 0, d.instance.instance_variable_get('@writer_current_position')
-      d.instance.submit_flush
-      assert_equal 0, d.instance.instance_variable_get('@writer_current_position')
-      d.instance.submit_flush
-      assert_equal 0, d.instance.instance_variable_get('@writer_current_position')
-      d.instance.submit_flush
-      assert_equal 0, d.instance.instance_variable_get('@writer_current_position')
-      d.instance.shutdown
-      assert_equal 1, d.instance.submit_flush_threads.size
-
-      # num_threads 4
-      d = create_mock_driver(CONFIG + %[num_threads 4])
-      d.instance.start
-      assert_equal 0, d.instance.instance_variable_get('@writer_current_position')
-      d.instance.submit_flush
-      assert_equal 1, d.instance.instance_variable_get('@writer_current_position')
-      d.instance.submit_flush
-      assert_equal 2, d.instance.instance_variable_get('@writer_current_position')
-      d.instance.submit_flush
-      assert_equal 3, d.instance.instance_variable_get('@writer_current_position')
-      d.instance.submit_flush
-      assert_equal 0, d.instance.instance_variable_get('@writer_current_position')
-      d.instance.shutdown
-      assert (d.instance.submit_flush_threads.size > 1), "fails if only one thread works to submit flush"
-    end
-
     def test_secondary
-      d = create_driver(CONFIG + %[
+      d = Fluent::Test::BufferedOutputTestDriver.new(Fluent::BufferedOutput) do
+        def write(chunk)
+          chunk.read
+        end
+      end
+
+      mock(d.instance.log).warn("secondary type should be same with primary one",
+                                { primary: d.instance.class.to_s, secondary: "Fluent::Plugin::Test2Output" })
+      d.configure(CONFIG + %[
         <secondary>
-          type test
+          type test2
           name c0
         </secondary>
       ])
+
       assert_not_nil d.instance.instance_variable_get(:@secondary).router
     end
 
-    sub_test_case "test_force_flush" do
-      setup do
-        time = Time.parse("2011-01-02 13:14:15 UTC")
-        Timecop.freeze(time)
-        @time = time.to_i
-      end
+    def test_secondary_with_no_warn_log
+      # ObjectBufferedOutput doesn't implement `custom_filter`
+      d = Fluent::Test::BufferedOutputTestDriver.new(Fluent::ObjectBufferedOutput)
 
-      teardown do
-        Timecop.return
-      end
+      mock(d.instance.log).warn("secondary type should be same with primary one",
+                                { primary: d.instance.class.to_s, secondary: "Fluent::Plugin::Test2Output" }).never
+      d.configure(CONFIG + %[
+        <secondary>
+          type test2
+          name c0
+        </secondary>
+      ])
 
-      test "force_flush works on retrying" do
-        d = create_driver(CONFIG)
-        d.instance.start
-        buffer = d.instance.instance_variable_get(:@buffer)
-        # imitate 10 failures
-        d.instance.instance_variable_set(:@num_errors, 10)
-        d.instance.instance_variable_set(:@next_retry_time, @time + d.instance.calc_retry_wait)
-        # buffer should be popped (flushed) immediately
-        flexmock(buffer).should_receive(:pop).once
-        # force_flush
-        buffer.emit("test", 'test', NullOutputChain.instance)
-        d.instance.force_flush
-        10.times { sleep 0.05 }
-      end
+      assert_not_nil d.instance.instance_variable_get(:@secondary).router
     end
 
-    sub_test_case "test slow_flush_log_threshold" do
-      def create_slow_driver(conf, sleep_time)
-        d = Fluent::Test::BufferedOutputTestDriver.new(Fluent::BufferedOutput) do
-          attr_accessor :sleep_time
-
-          def initialize
-            super
-            @_written_check_mutex = Mutex.new
-            @_written_check = false
-          end
-
-          def written_check
-            @_written_check_mutex.synchronize { @_written_check }
-          end
-
-          def write(chunk)
-            sleep @sleep_time
-          end
-
-          def try_flush
-            super
-            @_written_check_mutex.synchronize { @_written_check = true }
-          end
-        end.configure(conf)
-        d.instance.sleep_time = sleep_time
-        d
-      end
+    test 'BufferQueueLimitError compatibility' do
+      assert_equal Fluent::Plugin::Buffer::BufferOverflowError, Fluent::BufferQueueLimitError
+    end
+  end
 
-      def setup
-        # output#try_flush uses $log, so it should be replaced
-        @orig_log = $log
-        $log = Fluent::Test::TestLogger.new
-      end
+  class ObjectBufferedOutputTest < ::Test::Unit::TestCase
+    include FluentOutputTest
 
-      def teardown
-        $log = @orig_log
-      end
+    def setup
+      Fluent::Test.setup
+    end
 
-      test "flush took longer time than slow_flush_log_threshold" do
-        d = create_slow_driver(%[
-          slow_flush_log_threshold 0.5
-        ], 1.5)
-        run_driver(d)
-        assert_equal 1, $log.logs.count { |line| line =~ /buffer flush took longer time than slow_flush_log_threshold:/ }
-      end
+    CONFIG = %[]
 
-      test "flush took lower time than slow_flush_log_threshold. No logs" do
-        d = create_slow_driver(%[
-          slow_flush_log_threshold 5.0
-        ], 0)
-        run_driver(d)
-        assert_equal 0, $log.logs.count { |line| line =~ /buffer flush took longer time than slow_flush_log_threshold:/ }
-      end
+    def create_driver(conf=CONFIG)
+      Fluent::Test::OutputTestDriver.new(Fluent::ObjectBufferedOutput).configure(conf, true)
+    end
 
-      def run_driver(d)
-        d.instance.start
-        d.instance.emit('test', OneEventStream.new(@time.to_i, {"message" => "foo"}), NullOutputChain.instance)
-        d.instance.force_flush
-        until d.instance.written_check; end
-      end
+    def test_configure
+      # default
+      d = create_driver
+      assert_equal true, d.instance.time_as_integer
     end
   end
 
@@ -278,37 +181,51 @@ module FluentOutputTest
 
     TMP_DIR = File.expand_path(File.dirname(__FILE__) + "/tmp/time_sliced_output")
 
-    CONFIG = %[buffer_path #{TMP_DIR}/foo]
+    CONFIG = %[
+      buffer_path #{TMP_DIR}/foo
+      time_slice_format %Y%m%d%H
+    ]
+
+    class TimeSlicedOutputTestPlugin < Fluent::TimeSlicedOutput
+      attr_reader :written_chunk_keys, :errors_in_write
+      def initialize
+        super
+        @written_chunk_keys = []
+        @errors_in_write = []
+      end
 
-    def create_driver(conf=CONFIG)
-      Fluent::Test::TimeSlicedOutputTestDriver.new(Fluent::TimeSlicedOutput).configure(conf, true)
-    end
+      def configure(conf)
+        super
 
-    sub_test_case "force_flush test" do
-      setup do
-        time = Time.parse("2011-01-02 13:14:15 UTC")
-        Timecop.freeze(time)
-        @es = OneEventStream.new(time.to_i, {"message" => "foo"})
+        @formatter = Fluent::Plugin.new_formatter('out_file')
+        @formatter.configure(conf)
       end
 
-      teardown do
-        Timecop.return
+      def format(tag, time, record)
+        @formatter.format(tag, time, record)
       end
-
-      test "force_flush immediately flushes" do
-        d = create_driver(CONFIG + %[
-          time_format %Y%m%d%H%M%S
-        ])
-        d.instance.start
-        # buffer should be popped (flushed) immediately
-        flexmock(d.instance.instance_variable_get(:@buffer)).should_receive(:pop).once
-        # force_flush
-        d.instance.emit('test', @es, NullOutputChain.instance)
-        d.instance.force_flush
-        10.times { sleep 0.05 }
+      def write(chunk)
+        @written_chunk_keys << chunk.key
+        true
+      rescue => e
+        @errors_in_write << e
       end
     end
 
+    def create_driver(conf=CONFIG)
+      Fluent::Test::TimeSlicedOutputTestDriver.new(TimeSlicedOutputTestPlugin).configure(conf, true)
+    end
+
+    data(:none => '',
+         :utc => "utc",
+         :localtime => 'localtime',
+         :timezone => 'timezone +0000')
+    test 'configure with timezone related parameters' do |param|
+      assert_nothing_raised {
+        create_driver(CONFIG + param)
+      }
+    end
+
     sub_test_case "test emit" do
       setup do
         @time = Time.parse("2011-01-02 13:14:15 UTC")
@@ -319,18 +236,37 @@ module FluentOutputTest
         Timecop.return
       end
 
-      test "emit with valid event" do
+      test "emit with invalid event" do
         d = create_driver
         d.instance.start
-        d.instance.emit('test', OneEventStream.new(@time.to_i, {"message" => "foo"}), NullOutputChain.instance)
-        assert_equal 0, d.instance.log.logs.size
+        d.instance.after_start
+        assert_raise ArgumentError, "time must be a Fluent::EventTime (or Integer)" do
+          d.instance.emit_events('test', OneEventStream.new('string', 10))
+        end
       end
 
-      test "emit with invalid event" do
+      test "plugin can get key of chunk in #write" do
         d = create_driver
         d.instance.start
-        d.instance.emit('test', OneEventStream.new('string', 10), NullOutputChain.instance)
-        assert_equal 1, d.instance.log.logs.count { |line| line =~ /dump an error event/ }
+        d.instance.after_start
+        d.instance.emit_events('test', OneEventStream.new(event_time("2016-11-08 17:44:30 +0900"), {"message" => "yay"}))
+        d.instance.force_flush
+        waiting(10) do
+          sleep 0.1 until d.instance.written_chunk_keys.size == 1
+        end
+        assert_equal [], d.instance.errors_in_write
+        assert_equal ["2016110808"], d.instance.written_chunk_keys # default timezone is UTC
+      end
+
+      test "check formatted time compatibility with utc. Should Z, not +00:00" do
+        d = create_driver(CONFIG + %[
+          utc
+          include_time_key
+        ])
+        time = Time.parse("2016-11-08 12:00:00 UTC").to_i
+        d.emit({"a" => 1}, time)
+        d.expect_format %[2016-11-08T12:00:00Z\ttest\t{"a":1,"time":"2016-11-08T12:00:00Z"}\n]
+        d.run
       end
     end
   end

data/test/test_plugin.rb

@@ -0,0 +1,251 @@
+require_relative 'helper'
+
+require 'fluent/plugin'
+require 'fluent/plugin/input'
+require 'fluent/plugin/filter'
+require 'fluent/plugin/output'
+require 'fluent/plugin/buffer'
+require 'fluent/plugin/parser'
+require 'fluent/plugin/formatter'
+require 'fluent/plugin/storage'
+
+class PluginTest < Test::Unit::TestCase
+  class Dummy1Input < Fluent::Plugin::Input
+    Fluent::Plugin.register_input('plugin_test_dummy1', self)
+  end
+  class Dummy2Input < Fluent::Plugin::Input
+    Fluent::Plugin.register_input('plugin_test_dummy2', self)
+    helpers :storage
+    config_section :storage do
+      config_set_default :@type, 'plugin_test_dummy1'
+    end
+    def multi_workers_ready?
+      true
+    end
+  end
+  class DummyFilter < Fluent::Plugin::Filter
+    Fluent::Plugin.register_filter('plugin_test_dummy', self)
+    helpers :parser, :formatter
+    config_section :parse do
+      config_set_default :@type, 'plugin_test_dummy'
+    end
+    config_section :format do
+      config_set_default :@type, 'plugin_test_dummy'
+    end
+    def filter(tag, time, record)
+      record
+    end
+  end
+  class Dummy1Output < Fluent::Plugin::Output
+    Fluent::Plugin.register_output('plugin_test_dummy1', self)
+    def write(chunk)
+      # drop
+    end
+  end
+  class Dummy2Output < Fluent::Plugin::Output
+    Fluent::Plugin.register_output('plugin_test_dummy2', self)
+    config_section :buffer do
+      config_set_default :@type, 'plugin_test_dummy1'
+    end
+    def multi_workers_ready?
+      true
+    end
+    def write(chunk)
+      # drop
+    end
+  end
+  class Dummy1Buffer < Fluent::Plugin::Buffer
+    Fluent::Plugin.register_buffer('plugin_test_dummy1', self)
+  end
+  class Dummy2Buffer < Fluent::Plugin::Buffer
+    Fluent::Plugin.register_buffer('plugin_test_dummy2', self)
+    def multi_workers_ready?
+      false
+    end
+  end
+  class DummyParser < Fluent::Plugin::Parser
+    Fluent::Plugin.register_parser('plugin_test_dummy', self)
+  end
+  class DummyFormatter < Fluent::Plugin::Formatter
+    Fluent::Plugin.register_formatter('plugin_test_dummy', self)
+  end
+  class Dummy1Storage < Fluent::Plugin::Storage
+    Fluent::Plugin.register_storage('plugin_test_dummy1', self)
+  end
+  class Dummy2Storage < Fluent::Plugin::Storage
+    Fluent::Plugin.register_storage('plugin_test_dummy2', self)
+    def multi_workers_ready?
+      false
+    end
+  end
+  class DummyOwner < Fluent::Plugin::Base
+    include Fluent::PluginId
+    include Fluent::PluginLoggerMixin
+  end
+  class DummyEventRouter
+    def emit(tag, time, record); end
+    def emit_array(tag, array); end
+    def emit_stream(tag, es); end
+    def emit_error_event(tag, time, record, error); end
+  end
+
+  sub_test_case '#new_* methods' do
+    data(
+      input1: ['plugin_test_dummy1', Dummy1Input, :new_input],
+      input2: ['plugin_test_dummy2', Dummy2Input, :new_input],
+      filter: ['plugin_test_dummy', DummyFilter, :new_filter],
+      output1: ['plugin_test_dummy1', Dummy1Output, :new_output],
+      output2: ['plugin_test_dummy2', Dummy2Output, :new_output],
+    )
+    test 'returns plugin instances of registered plugin classes' do |(type, klass, m)|
+      instance = Fluent::Plugin.__send__(m, type)
+      assert_kind_of klass, instance
+    end
+
+    data(
+      buffer1: ['plugin_test_dummy1', Dummy1Buffer, :new_buffer],
+      buffer2: ['plugin_test_dummy2', Dummy2Buffer, :new_buffer],
+      parser: ['plugin_test_dummy', DummyParser, :new_parser],
+      formatter: ['plugin_test_dummy', DummyFormatter, :new_formatter],
+      storage1: ['plugin_test_dummy1', Dummy1Storage, :new_storage],
+      storage2: ['plugin_test_dummy2', Dummy2Storage, :new_storage],
+    )
+    test 'returns plugin instances of registered owned plugin classes' do |(type, klass, m)|
+      owner = DummyOwner.new
+      instance = Fluent::Plugin.__send__(m, type, parent: owner)
+      assert_kind_of klass, instance
+    end
+
+    data(
+      input1: ['plugin_test_dummy1', Dummy1Input, :new_input, nil],
+      input2: ['plugin_test_dummy2', Dummy2Input, :new_input, nil],
+      filter: ['plugin_test_dummy', DummyFilter, :new_filter, nil],
+      output1: ['plugin_test_dummy1', Dummy1Output, :new_output, nil],
+      output2: ['plugin_test_dummy2', Dummy2Output, :new_output, nil],
+      buffer1: ['plugin_test_dummy1', Dummy1Buffer, :new_buffer, {parent: DummyOwner.new}],
+      buffer2: ['plugin_test_dummy2', Dummy2Buffer, :new_buffer, {parent: DummyOwner.new}],
+      parser: ['plugin_test_dummy', DummyParser, :new_parser, {parent: DummyOwner.new}],
+      formatter: ['plugin_test_dummy', DummyFormatter, :new_formatter, {parent: DummyOwner.new}],
+      storage1: ['plugin_test_dummy1', Dummy1Storage, :new_storage, {parent: DummyOwner.new}],
+      storage2: ['plugin_test_dummy2', Dummy2Storage, :new_storage, {parent: DummyOwner.new}],
+    )
+    test 'returns plugin instances which are extended by FeatureAvailabilityChecker module' do |(type, _, m, kwargs)|
+      instance = if kwargs
+                   Fluent::Plugin.__send__(m, type, **kwargs)
+                 else
+                   Fluent::Plugin.__send__(m, type)
+                 end
+      assert_kind_of Fluent::Plugin::FeatureAvailabilityChecker, instance
+    end
+  end
+
+  sub_test_case 'with default system configuration' do
+    data(
+      input1: ['plugin_test_dummy1', Dummy1Input, :new_input, nil],
+      input2: ['plugin_test_dummy2', Dummy2Input, :new_input, nil],
+      filter: ['plugin_test_dummy', DummyFilter, :new_filter, nil],
+      output1: ['plugin_test_dummy1', Dummy1Output, :new_output, nil],
+      output2: ['plugin_test_dummy2', Dummy2Output, :new_output, nil],
+      buffer1: ['plugin_test_dummy1', Dummy1Buffer, :new_buffer, {parent: DummyOwner.new}],
+      buffer2: ['plugin_test_dummy2', Dummy2Buffer, :new_buffer, {parent: DummyOwner.new}],
+      parser: ['plugin_test_dummy', DummyParser, :new_parser, {parent: DummyOwner.new}],
+      formatter: ['plugin_test_dummy', DummyFormatter, :new_formatter, {parent: DummyOwner.new}],
+      storage1: ['plugin_test_dummy1', Dummy1Storage, :new_storage, {parent: DummyOwner.new}],
+      storage2: ['plugin_test_dummy2', Dummy2Storage, :new_storage, {parent: DummyOwner.new}],
+    )
+    test '#configure does not raise anything' do |(type, _, m, kwargs)|
+      instance = if kwargs
+                   Fluent::Plugin.__send__(m, type, **kwargs)
+                 else
+                   Fluent::Plugin.__send__(m, type)
+                 end
+      if instance.respond_to?(:context_router=)
+        instance.context_router = DummyEventRouter.new
+      end
+      assert_nothing_raised do
+        instance.configure(config_element())
+      end
+    end
+  end
+
+  sub_test_case 'with single worker configuration' do
+    data(
+      input1: ['plugin_test_dummy1', Dummy1Input, :new_input, nil],
+      input2: ['plugin_test_dummy2', Dummy2Input, :new_input, nil],
+      filter: ['plugin_test_dummy', DummyFilter, :new_filter, nil],
+      output1: ['plugin_test_dummy1', Dummy1Output, :new_output, nil],
+      output2: ['plugin_test_dummy2', Dummy2Output, :new_output, nil],
+      buffer1: ['plugin_test_dummy1', Dummy1Buffer, :new_buffer, {parent: DummyOwner.new}],
+      buffer2: ['plugin_test_dummy2', Dummy2Buffer, :new_buffer, {parent: DummyOwner.new}],
+      parser: ['plugin_test_dummy', DummyParser, :new_parser, {parent: DummyOwner.new}],
+      formatter: ['plugin_test_dummy', DummyFormatter, :new_formatter, {parent: DummyOwner.new}],
+      storage1: ['plugin_test_dummy1', Dummy1Storage, :new_storage, {parent: DummyOwner.new}],
+      storage2: ['plugin_test_dummy2', Dummy2Storage, :new_storage, {parent: DummyOwner.new}],
+    )
+    test '#configure does not raise anything' do |(type, _, m, kwargs)|
+      instance = if kwargs
+                   Fluent::Plugin.__send__(m, type, **kwargs)
+                 else
+                   Fluent::Plugin.__send__(m, type)
+                 end
+      if instance.respond_to?(:context_router=)
+        instance.context_router = DummyEventRouter.new
+      end
+      assert_nothing_raised do
+        instance.system_config_override('workers' => 1)
+        instance.configure(config_element())
+      end
+    end
+  end
+
+  sub_test_case 'with multi workers configuration' do
+    data(
+      input1: ['plugin_test_dummy1', Dummy1Input, :new_input],
+      output1: ['plugin_test_dummy1', Dummy1Output, :new_output],
+    )
+    test '#configure raise configuration error if plugins are not ready for multi workers' do |(type, klass, new_method)|
+      conf = config_element()
+      instance = Fluent::Plugin.__send__(new_method, type)
+      if instance.respond_to?(:context_router=)
+        instance.context_router = DummyEventRouter.new
+      end
+      assert_raise Fluent::ConfigError.new("Plugin '#{type}' does not support multi workers configuration (#{klass})") do
+        instance.system_config_override('workers' => 3)
+        instance.configure(conf)
+      end
+    end
+
+    data(
+      input2: ['plugin_test_dummy2', Dummy2Input, :new_input], # with Dummy1Storage
+      filter: ['plugin_test_dummy', DummyFilter, :new_filter], # with DummyParser and DummyFormatter
+      output2: ['plugin_test_dummy2', Dummy2Output, :new_output], # with Dummy1Buffer
+    )
+    test '#configure does not raise any errors if plugins and its owned plugins are ready for multi workers' do |(type, _klass, new_method)|
+      conf = config_element()
+      instance = Fluent::Plugin.__send__(new_method, type)
+      if instance.respond_to?(:context_router=)
+        instance.context_router = DummyEventRouter.new
+      end
+      assert_nothing_raised do
+        instance.system_config_override('workers' => 3)
+        instance.configure(conf)
+      end
+    end
+
+    data(
+      input2: ['plugin_test_dummy2', Dummy2Input, :new_input, 'storage', 'plugin_test_dummy2', Dummy2Storage],
+      output2: ['plugin_test_dummy2', Dummy2Output, :new_output, 'buffer', 'plugin_test_dummy2', Dummy2Buffer],
+    )
+    test '#configure raise configuration error if configured owned plugins are not ready for multi workers' do |(type, _klass, new_method, subsection, subsection_type, problematic)|
+      conf = config_element('root', '', {}, [config_element(subsection, '', {'@type' => subsection_type})])
+      instance = Fluent::Plugin.__send__(new_method, type)
+      if instance.respond_to?(:context_router=)
+        instance.context_router = DummyEventRouter.new
+      end
+      assert_raise Fluent::ConfigError.new("Plugin '#{subsection_type}' does not support multi workers configuration (#{problematic})") do
+        instance.system_config_override('workers' => 3)
+        instance.configure(conf)
+      end
+    end
+  end
+end