diff --git a/.travis.yml b/.travis.yml
index 1cefc919fa..1f1110b07b 100644
--- a/.travis.yml
+++ b/.travis.yml
@@ -1,8 +1,8 @@
 language: ruby
 
 rvm:
-  - 2.0.0
   - 2.1
+  - 2.1.5
   - 2.2.3
   - 2.3.0
   - ruby-head
diff --git a/example/in_status.conf b/example/in_status.conf
new file mode 100644
index 0000000000..80b6df5b62
--- /dev/null
+++ b/example/in_status.conf
@@ -0,0 +1,10 @@
+<source>
+  @type status
+  emit_interval 3
+  tag "test"
+</source>
+
+<match test>
+  @type stdout
+</match>
+
diff --git a/lib/fluent/agent.rb b/lib/fluent/agent.rb
index 5080f2377c..f0262842b6 100644
--- a/lib/fluent/agent.rb
+++ b/lib/fluent/agent.rb
@@ -13,6 +13,9 @@
 #    See the License for the specific language governing permissions and
 #    limitations under the License.
 #
+
+# TODO consolidate w/ Label ?
+
 module Fluent
   require 'fluent/configurable'
   require 'fluent/engine'
@@ -78,7 +81,7 @@ def shutdown
       @started_filters.map { |f|
         Thread.new do
           begin
-            log.info "shutting down filter#{@context.nil? ? '' : " in #{@context}"}", type: Plugin.lookup_name_from_class(f.class), plugin_id: f.plugin_id
+            log.info "shutting down filter#{@context.nil? ? '' : " in #{@context}"}", type: Plugin.lookup_type_from_class(f.class), plugin_id: f.plugin_id
             f.shutdown
           rescue => e
             log.warn "unexpected error while shutting down filter plugins", :plugin => f.class, :plugin_id => f.plugin_id, :error_class => e.class, :error => e
@@ -92,7 +95,7 @@ def shutdown
       @started_outputs.map { |o|
         Thread.new do
           begin
-            log.info "shutting down output#{@context.nil? ? '' : " in #{@context}"}", type: Plugin.lookup_name_from_class(o.class), plugin_id: o.plugin_id
+            log.info "shutting down output#{@context.nil? ? '' : " in #{@context}"}", type: Plugin.lookup_type_from_class(o.class), plugin_id: o.plugin_id
             o.shutdown
           rescue => e
             log.warn "unexpected error while shutting down output plugins", :plugin => o.class, :plugin_id => o.plugin_id, :error_class => e.class, :error => e
diff --git a/lib/fluent/command/debug.rb b/lib/fluent/command/debug.rb
index 22a21d18a5..a748d518af 100644
--- a/lib/fluent/command/debug.rb
+++ b/lib/fluent/command/debug.rb
@@ -85,7 +85,6 @@
 puts "Usage:"
 puts "    Engine.match('some.tag').output  : get an output plugin instance"
 puts "    Engine.sources[i]                : get input plugin instances"
-puts "    Plugin.load_plugin(type,name)    : load plugin class (use this if you get DRb::DRbUnknown)"
 puts ""
 
 Encoding.default_internal = nil if Encoding.respond_to?(:default_internal)
diff --git a/lib/fluent/command/fluentd.rb b/lib/fluent/command/fluentd.rb
index 6ba415d5ab..1f09488636 100644
--- a/lib/fluent/command/fluentd.rb
+++ b/lib/fluent/command/fluentd.rb
@@ -92,6 +92,10 @@
   opts[:without_source] = b
 }
 
+op.on('--plugin-storage-path DIR_PATH', "directory path which is used for storages of plugin internal data") {|s|
+  opts[:plugin_storage_path] = s
+}
+
 op.on('--use-v1-config', "Use v1 configuration format (default)", TrueClass) {|b|
   opts[:use_v1_config] = b
 }
diff --git a/lib/fluent/config.rb b/lib/fluent/config.rb
index 5ff253a714..cdeed1f52c 100644
--- a/lib/fluent/config.rb
+++ b/lib/fluent/config.rb
@@ -38,17 +38,4 @@ def self.new(name = '')
       Element.new(name, '', {}, [])
     end
   end
-
-  require 'fluent/configurable'
-
-  module PluginId
-    def configure(conf)
-      @id = conf['@id'] || conf['id']
-      super
-    end
-
-    def plugin_id
-      @id ? @id : "object:#{object_id.to_s(16)}"
-    end
-  end
 end
diff --git a/lib/fluent/config/configure_proxy.rb b/lib/fluent/config/configure_proxy.rb
index 5083da0b4a..5bccfa9658 100644
--- a/lib/fluent/config/configure_proxy.rb
+++ b/lib/fluent/config/configure_proxy.rb
@@ -77,19 +77,7 @@ def merge(other) # self is base class, other is subclass
         merged.argument = other.argument || self.argument
         merged.params = self.params.merge(other.params)
         merged.defaults = self.defaults.merge(other.defaults)
-        merged.sections = {}
-        (self.sections.keys + other.sections.keys).uniq.each do |section_key|
-          self_section = self.sections[section_key]
-          other_section = other.sections[section_key]
-          merged_section = if self_section && other_section
-                             self_section.merge(other_section)
-                           elsif self_section || other_section
-                             self_section || other_section
-                           else
-                             raise "BUG: both of self and other section are nil"
-                           end
-          merged.sections[section_key] = merged_section
-        end
+        merged.sections = self.sections.merge(other.sections)
 
         merged
       end
diff --git a/lib/fluent/config/section.rb b/lib/fluent/config/section.rb
index 8549e22fd3..d208493bad 100644
--- a/lib/fluent/config/section.rb
+++ b/lib/fluent/config/section.rb
@@ -33,6 +33,10 @@ def initialize(params = {})
 
       alias :object_id :__id__
 
+      def to_s
+        inspect
+      end
+
       def inspect
         "<Fluent::Config::Section #{@params.to_json}>"
       end
@@ -62,6 +66,19 @@ def [](key)
         @params[key.to_sym]
       end
 
+      def respond_to?(symbol, include_all=false)
+        case symbol
+        when :inspect, :nil?, :to_h, :+, :instance_of?, :kind_of?, :[], :respond_to?, :respond_to_missing?, :method_missing,
+          true
+        when :!, :!= , :==, :equal?, :instance_eval, :instane_exec
+          true
+        when :method_missing, :singleton_method_added, :singleton_method_removed, :singleton_method_undefined
+          include_all
+        else
+          false
+        end
+      end
+
       def respond_to_missing?(symbol, include_private)
         @params.has_key?(symbol)
       end
@@ -70,7 +87,7 @@ def method_missing(name, *args)
         if @params.has_key?(name)
           @params[name]
         else
-          super
+          ::Kernel.raise ::NoMethodError, "undefined method `#{name}' for #{self.inspect}"
         end
       end
     end
diff --git a/lib/fluent/configurable.rb b/lib/fluent/configurable.rb
index a17008ed2a..280810890e 100644
--- a/lib/fluent/configurable.rb
+++ b/lib/fluent/configurable.rb
@@ -14,12 +14,13 @@
 #    limitations under the License.
 #
 
-module Fluent
-  require 'fluent/config/configure_proxy'
-  require 'fluent/config/section'
-  require 'fluent/config/error'
-  require 'fluent/registry'
+require 'fluent/config/configure_proxy'
+require 'fluent/config/section'
+require 'fluent/config/error'
+require 'fluent/registry'
+require 'fluent/plugin'
 
+module Fluent
   module Configurable
     def self.included(mod)
       mod.extend(ClassMethods)
@@ -50,9 +51,13 @@ def configure(conf)
       proxy = self.class.merged_configure_proxy
       conf.corresponding_proxies << proxy
 
-      # In the nested section, can't get plugin class through proxies so get plugin class here
-      plugin_class = Plugin.lookup_name_from_class(proxy.name.to_s)
-      root = Fluent::Config::SectionGenerator.generate(proxy, conf, logger, plugin_class)
+      # Configuration sections must have plugin types to show unused parameters (for what type of plugin)
+      # in configuration files,
+      # but nested sections cannot take the type of root configuration section.
+      # So we need to get plugin type here, and use it in configuration proxies.
+      # ("type" is a stuff specified by '@type' in configuration file)
+      plugin_type = Fluent::Plugin.lookup_type_from_class(proxy.name.to_s)
+      root = Fluent::Config::SectionGenerator.generate(proxy, conf, logger, plugin_type)
       @config_root_section = root
 
       root.instance_eval{ @params.keys }.each do |param_name|
diff --git a/lib/fluent/engine.rb b/lib/fluent/engine.rb
index 05883ffbe4..2029b76e6c 100644
--- a/lib/fluent/engine.rb
+++ b/lib/fluent/engine.rb
@@ -18,6 +18,7 @@ module Fluent
   require 'fluent/event_router'
   require 'fluent/root_agent'
   require 'fluent/time'
+  require 'fluent/system_config'
 
   class EngineClass
     def initialize
@@ -34,26 +35,30 @@ def initialize
 
       @msgpack_factory = MessagePack::Factory.new
       @msgpack_factory.register_type(Fluent::EventTime::TYPE, Fluent::EventTime)
+      @system_config = SystemConfig.new({})
     end
 
     MATCH_CACHE_SIZE = 1024
     LOG_EMIT_INTERVAL = 0.1
 
+    attr_reader :system_config
     attr_reader :root_agent
     attr_reader :matches, :sources
     attr_reader :msgpack_factory
 
     def init(opts = {})
       BasicSocket.do_not_reverse_lookup = true
-      Plugin.load_plugins
       if defined?(Encoding)
         Encoding.default_internal = 'ASCII-8BIT' if Encoding.respond_to?(:default_internal)
         Encoding.default_external = 'ASCII-8BIT' if Encoding.respond_to?(:default_external)
       end
 
+      @system_config = opts[:system_config] if opts[:system_config]
+
       suppress_interval(opts[:suppress_interval]) if opts[:suppress_interval]
       @suppress_config_dump = opts[:suppress_config_dump] if opts[:suppress_config_dump]
       @without_source = opts[:without_source] if opts[:without_source]
+      @plugin_storage_path = opts[:plugin_storage_path] if opts[:plugin_storage_path]
 
       @root_agent = RootAgent.new(opts)
 
@@ -113,22 +118,20 @@ def configure(conf)
       end
     end
 
-    def load_plugin_dir(dir)
-      Plugin.load_plugin_dir(dir)
+    def add_plugin_dir(dir)
+      Plugin.add_plugin_dir(dir)
     end
 
     def emit(tag, time, record)
-      unless record.nil?
-        emit_stream tag, OneEventStream.new(time, record)
-      end
+      raise "BUG: use router.emit instead of Engine.emit"
     end
 
     def emit_array(tag, array)
-      emit_stream tag, ArrayEventStream.new(array)
+      raise "BUG: use router.emit_array instead of Engine.emit_array"
     end
 
     def emit_stream(tag, es)
-      @event_router.emit_stream(tag, es)
+      raise "BUG: use router.emit_stream instead of Engine.emit_stream"
     end
 
     def flush!
diff --git a/lib/fluent/env.rb b/lib/fluent/env.rb
index 8f20db8906..0102a393d4 100644
--- a/lib/fluent/env.rb
+++ b/lib/fluent/env.rb
@@ -18,9 +18,9 @@ module Fluent
   DEFAULT_CONFIG_PATH = ENV['FLUENT_CONF'] || '/etc/fluent/fluent.conf'
   DEFAULT_PLUGIN_DIR = ENV['FLUENT_PLUGIN'] || '/etc/fluent/plugin'
   DEFAULT_SOCKET_PATH = ENV['FLUENT_SOCKET'] || '/var/run/fluent/fluent.sock'
-  DEFAULT_LISTEN_PORT = 24224
-  DEFAULT_FILE_PERMISSION = 0644
-  DEFAULT_DIR_PERMISSION = 0755
+  DEFAULT_LISTEN_PORT = 24224 # TODO: obsolete
+  DEFAULT_FILE_PERMISSION = 0644 # TODO: configurable w/ <system>
+  DEFAULT_DIR_PERMISSION = 0755 # TODO: configurable w/ <system>
   IS_WINDOWS = /mswin|mingw/ === RUBY_PLATFORM
   private_constant :IS_WINDOWS
 
diff --git a/lib/fluent/filter.rb b/lib/fluent/filter.rb
index b5da9c4982..6b7b046faf 100644
--- a/lib/fluent/filter.rb
+++ b/lib/fluent/filter.rb
@@ -16,6 +16,7 @@
 
 module Fluent
   class Filter
+    # TODO: move to plugin/filter.rb, and make interoperability layer here
     include Configurable
     include PluginId
     include PluginLoggerMixin
diff --git a/lib/fluent/formatter.rb b/lib/fluent/formatter.rb
index 5b14892f3a..85555207ef 100644
--- a/lib/fluent/formatter.rb
+++ b/lib/fluent/formatter.rb
@@ -14,9 +14,13 @@
 #    limitations under the License.
 #
 
-module Fluent
-  require 'fluent/registry'
+require 'fluent/registry'
+require 'fluent/configurable'
+require 'fluent/plugin'
+
+# Fluent::Plugin::Formatter ?
 
+module Fluent
   class Formatter
     include Configurable
 
@@ -240,7 +244,6 @@ def format(tag, time, record)
       end
     end
 
-    TEMPLATE_REGISTRY = Registry.new(:formatter_type, 'fluent/plugin/formatter_')
     {
       'out_file' => Proc.new { OutFileFormatter.new },
       'stdout' => Proc.new { StdoutFormatter.new },
@@ -251,23 +254,22 @@ def format(tag, time, record)
       'csv' => Proc.new { CsvFormatter.new },
       'single_value' => Proc.new { SingleValueFormatter.new },
     }.each { |name, factory|
-      TEMPLATE_REGISTRY.register(name, factory)
+      Fluent::Plugin.register_formatter(name, factory)
     }
 
     def self.register_template(name, factory_or_proc)
       factory = if factory_or_proc.is_a?(Class) # XXXFormatter
-                  Proc.new { factory_or_proc.new }
+                  factory_or_proc.new
                 elsif factory_or_proc.arity == 3 # Proc.new { |tag, time, record| }
                   Proc.new { ProcWrappedFormatter.new(factory_or_proc) }
                 else # Proc.new { XXXFormatter.new }
                   factory_or_proc
                 end
-
-      TEMPLATE_REGISTRY.register(name, factory)
+      Fluent::Plugin.register_formatter(name, factory)
     end
 
     def self.lookup(format)
-      TEMPLATE_REGISTRY.lookup(format).call
+      Fluent::Plugin.new_formatter(format)
     end
 
     # Keep backward-compatibility
diff --git a/lib/fluent/input.rb b/lib/fluent/input.rb
index 10a6022bae..e9b37cad7f 100644
--- a/lib/fluent/input.rb
+++ b/lib/fluent/input.rb
@@ -14,33 +14,10 @@
 #    limitations under the License.
 #
 
-module Fluent
-  class Input
-    include Configurable
-    include PluginId
-    include PluginLoggerMixin
-
-    attr_accessor :router
-
-    def initialize
-      super
-    end
-
-    def configure(conf)
-      super
+require 'fluent/plugin/input'
 
-      if label_name = conf['@label']
-        label = Engine.root_agent.find_label(label_name)
-        @router = label.event_router
-      elsif @router.nil?
-        @router = Engine.root_agent.event_router
-      end
-    end
-
-    def start
-    end
-
-    def shutdown
-    end
+module Fluent
+  class Input < Plugin::Input
+    # TODO: add interoperability layer
   end
 end
diff --git a/lib/fluent/load.rb b/lib/fluent/load.rb
index 200f09c8ec..e693450878 100644
--- a/lib/fluent/load.rb
+++ b/lib/fluent/load.rb
@@ -1,3 +1,6 @@
+# TODO: This file MUST be deleted
+#       all test (and implementation) files should require its dependency by itself
+
 require 'thread'
 require 'socket'
 require 'fcntl'
@@ -30,8 +33,8 @@
 require 'fluent/parser'
 require 'fluent/formatter'
 require 'fluent/event'
-require 'fluent/buffer'
-require 'fluent/input'
-require 'fluent/output'
+require 'fluent/plugin/buffer'
+require 'fluent/plugin/input'
+require 'fluent/plugin/output'
 require 'fluent/filter'
 require 'fluent/match'
diff --git a/lib/fluent/log.rb b/lib/fluent/log.rb
index f14f27c32f..85919fd09e 100644
--- a/lib/fluent/log.rb
+++ b/lib/fluent/log.rb
@@ -65,6 +65,9 @@ def initialize(out=STDERR, level=LEVEL_TRACE, opts={})
       # TODO: This variable name is unclear so we should change to better name.
       @threads_exclude_events = []
 
+      @optional_header = nil
+      @optional_attrs = nil
+
       if opts.has_key?(:suppress_repeated_stacktrace)
         @suppress_repeated_stacktrace = opts[:suppress_repeated_stacktrace]
       end
@@ -74,6 +77,7 @@ def initialize(out=STDERR, level=LEVEL_TRACE, opts={})
     attr_accessor :level
     attr_accessor :tag
     attr_accessor :time_format
+    attr_accessor :optional_header, :optional_attrs
 
     def enable_debug(b=true)
       @debug_mode = b
@@ -263,8 +267,8 @@ def dump_stacktrace(backtrace, level)
 
     def event(level, args)
       time = Time.now
-      message = ''
-      map = {}
+      message = @optional_header ? @optional_header.dup : ''
+      map = @optional_attrs ? @optional_attrs.dup : {}
       args.each {|a|
         if a.is_a?(Hash)
           a.each_pair {|k,v|
@@ -364,6 +368,13 @@ def configure(conf)
           @log = PluginLogger.new($log)
         end
         @log.level = @log_level
+        @log.optional_header = "[#{self.class.name}#{@_id_configured ? "(" + @id + ")" : ""}] "
+        @log.optional_attrs = {
+          'plugin_type' => self.class.name,
+        }
+        if @_id_configured
+          @log.optional_attrs.update({'plugin_id' => @id})
+        end
       end
     end
   end
diff --git a/lib/fluent/output.rb b/lib/fluent/output.rb
index c5873f1ca9..3ea9ba7428 100644
--- a/lib/fluent/output.rb
+++ b/lib/fluent/output.rb
@@ -14,598 +14,118 @@
 #    limitations under the License.
 #
 
-module Fluent
-  class OutputChain
-    def initialize(array, tag, es, chain=NullOutputChain.instance)
-      @array = array
-      @tag = tag
-      @es = es
-      @offset = 0
-      @chain = chain
-    end
-
-    def next
-      if @array.length <= @offset
-        return @chain.next
-      end
-      @offset += 1
-      result = @array[@offset-1].emit(@tag, @es, self)
-      result
-    end
-  end
-
-  class CopyOutputChain < OutputChain
-    def next
-      if @array.length <= @offset
-        return @chain.next
-      end
-      @offset += 1
-      es = @array.length > @offset ? @es.dup : @es
-      result = @array[@offset-1].emit(@tag, es, self)
-      result
-    end
-  end
+require 'fluent/plugin/output'
+require 'fluent/plugin/buffered_output'
+require 'fluent/plugin/object_buffered_output'
+require 'fluent/plugin/time_sliced_output'
 
-  class NullOutputChain
-    require 'singleton'
-    include Singleton
-
-    def next
-    end
-  end
+# This classes are for compatibility.
+# Fluent::Input (or other plugin base classes) are obsolete in v0.14.
 
+require 'fluent/plugin_support/emitter'
 
-  class Output
-    include Configurable
-    include PluginId
-    include PluginLoggerMixin
-
-    attr_accessor :router
-
+module Fluent
+  class EngineCompat
     def initialize
-      super
+      @router = nil
     end
 
-    def configure(conf)
-      super
-
-      if label_name = conf['@label']
-        label = Engine.root_agent.find_label(label_name)
-        @router = label.event_router
-      elsif @router.nil?
-        @router = Engine.root_agent.event_router
-      end
+    def reconfigure
+      @router = Fluent::Engine.root_agent.event_router
     end
 
-    def start
+    def emit(tag, time, record)
+      @router.emit(tag, time, record)
     end
 
-    def shutdown
+    def emit_array(tag, array)
+      @router.emit(tag, array)
     end
 
-    #def emit(tag, es, chain)
-    #end
-
-    def secondary_init(primary)
-      if primary.class != self.class
-        $log.warn "type of secondary output should be same as primary output", :primary=>primary.class.to_s, :secondary=>self.class.to_s
-      end
+    def emit_stream(tag, es)
+      @router.emit_stream(tag, es)
     end
-
-    def inspect; "#<%s:%014x>" % [self.class.name, '0x%014x' % (__id__<<1)] end
   end
 
+  module OutputPluginCompat
+    # TODO: add interoperability layer (especially for chain)
 
-  class OutputThread
-    def initialize(output)
-      @output = output
-      @finish = false
-      @next_time = Time.now.to_f + 1.0
-    end
-
-    def configure(conf)
-    end
+    # All traditional output plugins can emit events
+    include Fluent::PluginSupport::Emitter
 
-    def start
-      @mutex = Mutex.new
-      @cond = ConditionVariable.new
-      @thread = Thread.new(&method(:run))
-    end
-
-    def shutdown
-      @finish = true
-      @mutex.synchronize {
-        @cond.signal
-      }
-      Thread.pass
-      @thread.join
-    end
+    # to overwrite Fluent::Engine in traditional plugin code
+    module Fluent; end
 
-    def submit_flush
-      @mutex.synchronize {
-        @next_time = 0
-        @cond.signal
-      }
-      Thread.pass
-    end
-
-    private
-    def run
-      @mutex.lock
-      begin
-        until @finish
-          time = Time.now.to_f
-
-          if @next_time <= time
-            @mutex.unlock
-            begin
-              @next_time = @output.try_flush
-            ensure
-              @mutex.lock
-            end
-            next_wait = @next_time - Time.now.to_f
-          else
-            next_wait = @next_time - time
-          end
-
-          cond_wait(next_wait) if next_wait > 0
-        end
-      ensure
-        @mutex.unlock
-      end
-    rescue
-      $log.error "error on output thread", :error=>$!.to_s
-      $log.error_backtrace
-      raise
-    ensure
-      @mutex.synchronize {
-        @output.before_shutdown
-      }
-    end
-
-    def cond_wait(sec)
-      @cond.wait(@mutex, sec)
-    end
-  end
-
-
-  class BufferedOutput < Output
-    def initialize
-      super
-      @next_flush_time = 0
-      @last_retry_time = 0
-      @next_retry_time = 0
-      @num_errors = 0
-      @num_errors_lock = Mutex.new
-      @secondary_limit = 8
-      @emit_count = 0
-    end
-
-    desc 'The buffer type (memory, file)'
-    config_param :buffer_type, :string, :default => 'memory'
-    desc 'The interval between data flushes.'
-    config_param :flush_interval, :time, :default => 60
-    config_param :try_flush_interval, :float, :default => 1
-    desc 'If true, the value of `retry_value` is ignored and there is no limit'
-    config_param :disable_retry_limit, :bool, :default => false
-    desc 'The limit on the number of retries before buffered data is discarded'
-    config_param :retry_limit, :integer, :default => 17
-    desc 'The initial intervals between write retries.'
-    config_param :retry_wait, :time, :default => 1.0
-    desc 'The maximum intervals between write retries.'
-    config_param :max_retry_wait, :time, :default => nil
-    desc 'The number of threads to flush the buffer.'
-    config_param :num_threads, :integer, :default => 1
-    desc 'The interval between data flushes for queued chunk.'
-    config_param :queued_chunk_flush_interval, :time, :default => 1
+    Fluent::Engine = Engine = EngineCompat.new # Engine.root_agent is not initialized yet
 
     def configure(conf)
       super
-
-      @retry_wait = @retry_wait.to_f # converted to Float for calc_retry_wait
-      @buffer = Plugin.new_buffer(@buffer_type)
-      @buffer.configure(conf)
-
-      if @buffer.respond_to?(:enable_parallel)
-        if @num_threads == 1
-          @buffer.enable_parallel(false)
-        else
-          @buffer.enable_parallel(true)
-        end
-      end
-
-      @writers = (1..@num_threads).map {
-        writer = OutputThread.new(self)
-        writer.configure(conf)
-        writer
-      }
-
-      if sconf = conf.elements.select {|e| e.name == 'secondary' }.first
-        type = sconf['@type'] || conf['@type'] || sconf['type'] || conf['type']
-        @secondary = Plugin.new_output(type)
-        @secondary.router = router
-        @secondary.configure(sconf)
-
-        if secondary_limit = conf['secondary_limit']
-          @secondary_limit = secondary_limit.to_i
-          if @secondary_limit < 0
-            raise ConfigError, "invalid parameter 'secondary_limit #{secondary_limit}'"
-          end
-        end
-
-        @secondary.secondary_init(self)
-      end
-    end
-
-    def start
-      @next_flush_time = Time.now.to_f + @flush_interval
-      @buffer.start
-      @secondary.start if @secondary
-      @writers.each {|writer| writer.start }
-      @writer_current_position = 0
-      @writers_size = @writers.size
-    end
-
-    def shutdown
-      @writers.each {|writer| writer.shutdown }
-      @secondary.shutdown if @secondary
-      @buffer.shutdown
+      # set root_agent.event_router here
+      Engine.reconfigure
     end
+  end
 
-    def emit(tag, es, chain, key="")
-      @emit_count += 1
-      data = format_stream(tag, es)
-      if @buffer.emit(key, data, chain)
-        submit_flush
-      end
-    end
+  class Output < Plugin::Output
+    include OutputPluginCompat
+  end
 
-    def submit_flush
-      # Without locks: it is rough but enough to select "next" writer selection
-      @writer_current_position = (@writer_current_position + 1) % @writers_size
-      @writers[@writer_current_position].submit_flush
-    end
+  class BufferedOutput < Plugin::BufferedOutput
+    include OutputPluginCompat
+  end
 
-    def format_stream(tag, es)
-      out = ''
-      es.each {|time,record|
-        out << format(tag, time, record)
-      }
-      out
-    end
+  class ObjectBufferedOutput < Plugin::ObjectBufferedOutput
+    include OutputPluginCompat
+  end
 
-    #def format(tag, time, record)
-    #end
+  class TimeSlicedOutput < Plugin::TimeSlicedOutput
+    include OutputPluginCompat
+  end
 
-    #def write(chunk)
+  class MultiOutput < Output
+    #def outputs
+    # # TODO
     #end
-
-    def enqueue_buffer(force = false)
-      @buffer.keys.each {|key|
-        @buffer.push(key)
-      }
-    end
-
-    def try_flush
-      time = Time.now.to_f
-
-      empty = @buffer.queue_size == 0
-      if empty && @next_flush_time < (now = Time.now.to_f)
-        @buffer.synchronize do
-          if @next_flush_time < now
-            enqueue_buffer
-            @next_flush_time = now + @flush_interval
-            empty = @buffer.queue_size == 0
-          end
-        end
-      end
-      if empty
-        return time + @try_flush_interval
-      end
-
-      begin
-        retrying = !@num_errors.zero?
-
-        if retrying
-          @num_errors_lock.synchronize do
-            if retrying = !@num_errors.zero? # re-check in synchronize
-              if @next_retry_time >= time
-                # allow retrying for only one thread
-                return time + @try_flush_interval
-              end
-              # assume next retry failes and
-              # clear them if when it succeeds
-              @last_retry_time = time
-              @num_errors += 1
-              @next_retry_time += calc_retry_wait
-            end
-          end
-        end
-
-        if @secondary && !@disable_retry_limit && @num_errors > @retry_limit
-          has_next = flush_secondary(@secondary)
-        else
-          has_next = @buffer.pop(self)
-        end
-
-        # success
-        if retrying
-          @num_errors = 0
-          # Note: don't notify to other threads to prevent
-          #       burst to recovered server
-          $log.warn "retry succeeded.", :plugin_id=>plugin_id
-        end
-
-        if has_next
-          return Time.now.to_f + @queued_chunk_flush_interval
-        else
-          return time + @try_flush_interval
-        end
-
-      rescue => e
-        if retrying
-          error_count = @num_errors
-        else
-          # first error
-          error_count = 0
-          @num_errors_lock.synchronize do
-            if @num_errors.zero?
-              @last_retry_time = time
-              @num_errors += 1
-              @next_retry_time = time + calc_retry_wait
-            end
-          end
-        end
-
-        if @disable_retry_limit || error_count < @retry_limit
-          $log.warn "temporarily failed to flush the buffer.", :next_retry=>Time.at(@next_retry_time), :error_class=>e.class.to_s, :error=>e.to_s, :plugin_id=>plugin_id
-          $log.warn_backtrace e.backtrace
-
-        elsif @secondary
-          if error_count == @retry_limit
-            $log.warn "failed to flush the buffer.", :error_class=>e.class.to_s, :error=>e.to_s, :plugin_id=>plugin_id
-            $log.warn "retry count exceededs limit. falling back to secondary output."
-            $log.warn_backtrace e.backtrace
-            retry  # retry immediately
-          elsif error_count <= @retry_limit + @secondary_limit
-            $log.warn "failed to flush the buffer, next retry will be with secondary output.", :next_retry=>Time.at(@next_retry_time), :error_class=>e.class.to_s, :error=>e.to_s, :plugin_id=>plugin_id
-            $log.warn_backtrace e.backtrace
-          else
-            $log.warn "failed to flush the buffer.", :error_class=>e.class, :error=>e.to_s, :plugin_id=>plugin_id
-            $log.warn "secondary retry count exceededs limit."
-            $log.warn_backtrace e.backtrace
-            write_abort
-            @num_errors = 0
-          end
-
-        else
-          $log.warn "failed to flush the buffer.", :error_class=>e.class.to_s, :error=>e.to_s, :plugin_id=>plugin_id
-          $log.warn "retry count exceededs limit."
-          $log.warn_backtrace e.backtrace
-          write_abort
-          @num_errors = 0
-        end
-
-        return @next_retry_time
-      end
-    end
-
-    def force_flush
-      @num_errors_lock.synchronize do
-        @next_retry_time = Time.now.to_f - 1
-      end
-      enqueue_buffer(true)
-      submit_flush
-    end
-
-    def before_shutdown
-      begin
-        @buffer.before_shutdown(self)
-      rescue
-        $log.warn "before_shutdown failed", :error=>$!.to_s
-        $log.warn_backtrace
-      end
-    end
-
-    def calc_retry_wait
-      # TODO retry pattern
-      wait = if @disable_retry_limit || @num_errors <= @retry_limit
-               @retry_wait * (2 ** (@num_errors - 1))
-             else
-               # secondary retry
-               @retry_wait * (2 ** (@num_errors - 2 - @retry_limit))
-             end
-      retry_wait = wait.finite? ? wait + (rand * (wait / 4.0) - (wait / 8.0)) : wait
-      @max_retry_wait ? [retry_wait, @max_retry_wait].min : retry_wait
-    end
-
-    def write_abort
-      $log.error "throwing away old logs."
-      begin
-        @buffer.clear!
-      rescue
-        $log.error "unexpected error while aborting", :error=>$!.to_s
-        $log.error_backtrace
-      end
-    end
-
-    def flush_secondary(secondary)
-      @buffer.pop(secondary)
-    end
   end
 
-
-  class ObjectBufferedOutput < BufferedOutput
-    config_param :time_as_integer, :bool, :default => true
-
-    def initialize
-      super
-    end
-
-    def emit(tag, es, chain)
-      @emit_count += 1
-      if @time_as_integer
-        data = es.to_msgpack_stream_forced_integer
-      else
-        data = es.to_msgpack_stream
-      end
-      key = tag
-      if @buffer.emit(key, data, chain)
-        submit_flush
-      end
+  # Output Chain does nothing currently.
+  # These will be removed at v1.
+  class OutputChain
+    def initialize(array, tag, es, chain=NullOutputChain.instance)
+      @array = array
+      @tag = tag
+      @es = es
+      @offset = 0
+      @chain = chain
     end
 
-    module BufferedEventStreamMixin
-      include Enumerable
-
-      def repeatable?
-        true
-      end
-
-      def each(&block)
-        msgpack_each(&block)
-      end
-
-      def to_msgpack_stream
-        read
+    def next
+      if @array.length <= @offset
+        return @chain.next
       end
-    end
-
-    def write(chunk)
-      chunk.extend(BufferedEventStreamMixin)
-      write_objects(chunk.key, chunk)
+      @offset += 1
+      result = @array[@offset-1].emit(@tag, @es, self)
+      result
     end
   end
 
-
-  class TimeSlicedOutput < BufferedOutput
-    require 'fluent/timezone'
-
-    def initialize
-      super
-      @localtime = true
-      #@ignore_old = false   # TODO
-    end
-
-    desc 'The time format used as part of the file name.'
-    config_param :time_slice_format, :string, :default => '%Y%m%d'
-    desc 'The amount of time Fluentd will wait for old logs to arrive.'
-    config_param :time_slice_wait, :time, :default => 10*60
-    desc 'Parse the time value in the specified timezone'
-    config_param :timezone, :string, :default => nil
-    config_set_default :buffer_type, 'file'  # overwrite default buffer_type
-    config_set_default :buffer_chunk_limit, 256*1024*1024  # overwrite default buffer_chunk_limit
-    config_set_default :flush_interval, nil
-
-    attr_accessor :localtime
-    attr_reader :time_slicer # for test
-
-    def configure(conf)
-      super
-
-      if conf['utc']
-        @localtime = false
-      elsif conf['localtime']
-        @localtime = true
-      end
-
-      if conf['timezone']
-        @timezone = conf['timezone']
-        Fluent::Timezone.validate!(@timezone)
-      end
-
-      if @timezone
-        @time_slicer = Timezone.formatter(@timezone, @time_slice_format)
-      elsif @localtime
-        @time_slicer = Proc.new {|time|
-          Time.at(time).strftime(@time_slice_format)
-        }
-      else
-        @time_slicer = Proc.new {|time|
-          Time.at(time).utc.strftime(@time_slice_format)
-        }
-      end
-
-      @time_slice_cache_interval = time_slice_cache_interval
-      @before_tc = nil
-      @before_key = nil
-
-      if @flush_interval
-        if conf['time_slice_wait']
-          $log.warn "time_slice_wait is ignored if flush_interval is specified: #{conf}"
-        end
-        @enqueue_buffer_proc = Proc.new do
-          @buffer.keys.each {|key|
-            @buffer.push(key)
-          }
-        end
-
-      else
-        @flush_interval = [60, @time_slice_cache_interval].min
-        @enqueue_buffer_proc = Proc.new do
-          nowslice = @time_slicer.call(Time.now - @time_slice_wait)
-          @buffer.keys.each {|key|
-            if key < nowslice
-              @buffer.push(key)
-            end
-          }
-        end
-      end
-    end
-
-    def emit(tag, es, chain)
-      @emit_count += 1
-      formatted_data = {}
-      es.each {|time,record|
-        tc = time / @time_slice_cache_interval
-        if @before_tc == tc
-          key = @before_key
-        else
-          @before_tc = tc
-          key = @time_slicer.call(time)
-          @before_key = key
-        end
-        formatted_data[key] ||= ''
-        formatted_data[key] << format(tag, time, record)
-      }
-      formatted_data.each { |key, data|
-        if @buffer.emit(key, data, chain)
-          submit_flush
-        end
-      }
-    end
-
-    def enqueue_buffer(force = false)
-      if force
-        @buffer.keys.each {|key|
-          @buffer.push(key)
-        }
-      else
-        @enqueue_buffer_proc.call
-      end
-    end
-
-    #def format(tag, event)
-    #end
-
-    private
-    def time_slice_cache_interval
-      if @time_slicer.call(0) != @time_slicer.call(60-1)
-        return 1
-      elsif @time_slicer.call(0) != @time_slicer.call(60*60-1)
-        return 30
-      elsif @time_slicer.call(0) != @time_slicer.call(24*60*60-1)
-        return 60*30
-      else
-        return 24*60*30
+  class CopyOutputChain < OutputChain
+    def next
+      if @array.length <= @offset
+        return @chain.next
       end
+      @offset += 1
+      es = @array.length > @offset ? @es.dup : @es
+      result = @array[@offset-1].emit(@tag, es, self)
+      result
     end
   end
 
+  class NullOutputChain
+    require 'singleton'
+    include Singleton
 
-  class MultiOutput < Output
-    #def outputs
-    #end
+    def next
+    end
   end
 end
 
diff --git a/lib/fluent/parser.rb b/lib/fluent/parser.rb
index b30b47a344..d1f23dc79e 100644
--- a/lib/fluent/parser.rb
+++ b/lib/fluent/parser.rb
@@ -14,9 +14,13 @@
 #    limitations under the License.
 #
 
-module Fluent
-  require 'fluent/registry'
+require 'fluent/registry'
+require 'fluent/configurable'
+require 'fluent/plugin'
+
+# TODO Fluent::Plugin::Parser ?
 
+module Fluent
   class ParserError < StandardError
   end
 
@@ -622,7 +626,6 @@ def check_format_regexp(format, key)
       end
     end
 
-    TEMPLATE_REGISTRY = Registry.new(:config_type, 'fluent/plugin/parser_')
     {
       'apache' => Proc.new { RegexpParser.new(/^(?<host>[^ ]*) [^ ]* (?<user>[^ ]*) \[(?<time>[^\]]*)\] "(?<method>\S+)(?: +(?<path>[^ ]*) +\S*)?" (?<code>[^ ]*) (?<size>[^ ]*)(?: "(?<referer>[^\"]*)" "(?<agent>[^\"]*)")?$/, {'time_format'=>"%d/%b/%Y:%H:%M:%S %z"}) },
       'apache_error' => Proc.new { RegexpParser.new(/^\[[^ ]* (?<time>[^\]]*)\] \[(?<level>[^\]]*)\](?: \[pid (?<pid>[^\]]*)\])?( \[client (?<client>[^\]]*)\])? (?<message>.*)$/) },
@@ -636,20 +639,21 @@ def check_format_regexp(format, key)
       'none' => Proc.new { NoneParser.new },
       'multiline' => Proc.new { MultilineParser.new },
     }.each { |name, factory|
-      TEMPLATE_REGISTRY.register(name, factory)
+      Fluent::Plugin.register_parser(name, factory)
     }
 
     def self.register_template(name, regexp_or_proc, time_format=nil)
-      if regexp_or_proc.is_a?(Class)
-        factory = Proc.new { regexp_or_proc.new }
-      elsif regexp_or_proc.is_a?(Regexp)
-        regexp = regexp_or_proc
-        factory = Proc.new { RegexpParser.new(regexp, {'time_format'=>time_format}) }
-      else
-        factory = regexp_or_proc
-      end
-
-      TEMPLATE_REGISTRY.register(name, factory)
+      factory = if regexp_or_proc.is_a?(Class)
+                  regexp_or_proc
+                elsif regexp_or_proc.is_a?(Regexp)
+                  regexp = regexp_or_proc
+                  Proc.new { RegexpParser.new(regexp, {'time_format'=>time_format}) }
+                elsif regexp_or_proc.respond_to? :call
+                  regexp_or_proc
+                else
+                  raise ArgumentError, "invalid factory for parser template: #{regexp_or_proc}"
+                end
+      Fluent::Plugin.register_parser(name, factory)
     end
 
     def self.lookup(format)
@@ -672,12 +676,10 @@ def self.lookup(format)
       else
         # built-in template
         begin
-          factory = TEMPLATE_REGISTRY.lookup(format)
+          Fluent::Plugin.new_parser(format)
         rescue ConfigError => e # keep same error message
           raise ConfigError, "Unknown format template '#{format}'"
         end
-
-        factory.call
       end
     end
 
diff --git a/lib/fluent/plugin.rb b/lib/fluent/plugin.rb
index da26d4d67c..4dfcce937b 100644
--- a/lib/fluent/plugin.rb
+++ b/lib/fluent/plugin.rb
@@ -14,162 +14,117 @@
 #    limitations under the License.
 #
 
-module Fluent
-  class PluginClass
-    # This class is refactored using Fluent::Registry at v0.14
+require 'fluent/registry'
+require 'fluent/config/error'
 
-    def initialize
-      @input = {}
-      @output = {}
-      @filter = {}
-      @buffer = {}
+module Fluent
+  module Plugin
+    SEARCH_PATHS = []
+
+    # plugins for fluentd:         fluent/plugin/type_NAME.rb
+    # plugins for fluentd plugins: fluent/plugin/type/NAME.rb
+    #   ex: storage, buffer(chunk), ...
+
+    INPUT_REGISTRY = Registry.new(:input_type, 'fluent/plugin/in_')
+    OUTPUT_REGISTRY = Registry.new(:output_type, 'fluent/plugin/out_')
+    FILTER_REGISTRY = Registry.new(:filter_type, 'fluent/plugin/filter_')
+    BUFFER_REGISTRY = Registry.new(:buffer_type, 'fluent/plugin/buf_')
+    PARSER_REGISTRY = Registry.new(:config_type, 'fluent/plugin/parser_')
+    FORMATTER_REGISTRY = Registry.new(:formatter_type, 'fluent/plugin/formatter_')
+    STORAGE_REGISTRY = Registry.new(:storage, 'fluent/plugin/storage/') # storage for plugins
+
+    REGISTRIES = [INPUT_REGISTRY, OUTPUT_REGISTRY, FILTER_REGISTRY, BUFFER_REGISTRY, PARSER_REGISTRY, FORMATTER_REGISTRY, STORAGE_REGISTRY]
+
+    def self.lookup_type_from_class(klass_or_its_name)
+      klass = if klass_or_its_name.is_a? Class
+                klass_or_its_name
+              elsif klass_or_its_name.is_a? String
+                eval(klass_or_its_name) # const_get can't handle qualified klass name (ex: A::B)
+              else
+                raise ArgumentError, "invalid argument type #{klass_or_its_name.class}: #{klass_or_its_name}"
+              end
+      REGISTRIES.reduce(nil){|a, r| a || r.reverse_lookup(klass) }
     end
 
-    def register_input(type, klass)
-      register_impl('input', @input, type, klass)
+    def self.add_plugin_dir(dir)
+      REGISTRIES.each do |r|
+        r.paths.push(dir)
+      end
+      nil
     end
 
-    def register_output(type, klass)
-      register_impl('output', @output, type, klass)
+    def self.register_input(type, klass)
+      register_impl('input', INPUT_REGISTRY, type, klass)
     end
 
-    def register_filter(type, klass)
-      register_impl('filter', @filter, type, klass)
+    def self.register_output(type, klass)
+      register_impl('output', OUTPUT_REGISTRY, type, klass)
     end
 
-    def register_buffer(type, klass)
-      register_impl('buffer', @buffer, type, klass)
+    def self.register_filter(type, klass)
+      register_impl('filter', FILTER_REGISTRY, type, klass)
     end
 
-    def register_parser(type, klass)
-      TextParser.register_template(type, klass)
+    def self.register_buffer(type, klass)
+      register_impl('buffer', BUFFER_REGISTRY, type, klass)
     end
 
-    def register_formatter(type, klass)
-      TextFormatter.register_template(type, klass)
+    def self.register_parser(type, klass_or_proc)
+      register_impl('parser', PARSER_REGISTRY, type, klass_or_proc)
     end
 
-    def new_input(type)
-      new_impl('input', @input, type)
+    def self.register_formatter(type, klass_or_proc)
+      register_impl('formatter', FORMATTER_REGISTRY, type, klass_or_proc)
     end
 
-    def new_output(type)
-      new_impl('output', @output, type)
+    def self.register_storage(type, klass)
+      register_impl('storage', STORAGE_REGISTRY, type, klass)
     end
 
-    def new_filter(type)
-      new_impl('filter', @filter, type)
+    def self.new_input(type)
+      new_impl('input', INPUT_REGISTRY, type)
     end
 
-    def new_buffer(type)
-      new_impl('buffer', @buffer, type)
+    def self.new_output(type)
+      new_impl('output', OUTPUT_REGISTRY, type)
     end
 
-    def new_parser(type)
-      TextParser.lookup(type)
+    def self.new_filter(type)
+      new_impl('filter', FILTER_REGISTRY, type)
     end
 
-    def new_formatter(type)
-      TextFormatter.lookup(type)
+    def self.new_buffer(type)
+      new_impl('buffer', BUFFER_REGISTRY, type)
     end
 
-    def load_plugins
-      dir = File.join(File.dirname(__FILE__), "plugin")
-      load_plugin_dir(dir)
+    def self.new_parser(type)
+      new_impl('parser', PARSER_REGISTRY, type)
     end
 
-    def load_plugin_dir(dir)
-      dir = File.expand_path(dir)
-      Dir.entries(dir).sort.each {|fname|
-        if fname =~ /\.rb$/
-          require File.join(dir, fname)
-        end
-      }
-      nil
+    def self.new_formatter(type)
+      new_impl('formatter', FORMATTER_REGISTRY, type)
     end
 
-    def load_plugin(type, name)
-      try_load_plugin(name, type)
+    def self.new_storage(type)
+      new_impl('storage', STORAGE_REGISTRY, type)
     end
 
-    def lookup_name_from_class(klass_or_str)
-      klass = if klass_or_str.class == String
-                eval(klass_or_str) # const_get can't handle A::B
-              else
-                klass_or_str
-              end
-
-      @input.each { |name, plugin|
-        return name if plugin == klass
-      }
-      @output.each { |name, plugin|
-        return name if plugin == klass
-      }
-      @filter.each { |name, plugin|
-        return name if plugin == klass
-      }
-
-      nil
-    end
-
-    private
-    def register_impl(name, map, type, klass)
-      map[type] = klass
+    def self.register_impl(name, registry, type, klass)
+      registry.register(type, klass)
       $log.trace { "registered #{name} plugin '#{type}'" }
       nil
     end
 
-    def new_impl(name, map, type)
-      if klass = map[type]
-        return klass.new
-      end
-      try_load_plugin(name, type)
-      if klass = map[type]
-        return klass.new
-      end
-      raise ConfigError, "Unknown #{name} plugin '#{type}'. Run 'gem search -rd fluent-plugin' to find plugins"
-    end
-
-    def try_load_plugin(name, type)
-      case name
-      when 'input'
-        path = "fluent/plugin/in_#{type}"
-      when 'output'
-        path = "fluent/plugin/out_#{type}"
-      when 'filter'
-        path = "fluent/plugin/filter_#{type}"
-      when 'buffer'
-        path = "fluent/plugin/buf_#{type}"
+    def self.new_impl(name, registry, type)
+      obj = registry.lookup(type)
+      case
+      when obj.is_a?(Class)
+        obj.new
+      when obj.respond_to?(:call)
+        obj.call
       else
-        return
-      end
-
-      # prefer LOAD_PATH than gems
-      files = $LOAD_PATH.map {|lp|
-        lpath = File.join(lp, "#{path}.rb")
-        File.exist?(lpath) ? lpath : nil
-      }.compact
-      unless files.empty?
-        # prefer newer version
-        require File.expand_path(files.sort.last)
-        return
-      end
-
-      # search gems
-      specs = Gem::Specification.find_all { |spec|
-        spec.contains_requirable_file? path
-      }
-
-      # prefer newer version
-      specs = specs.sort_by { |spec| spec.version }
-      if spec = specs.last
-        spec.require_paths.each { |lib|
-          file = "#{spec.full_gem_path}/#{lib}/#{path}"
-          require file
-        }
+        raise ConfigError, "Unknown #{name} plugin '#{type}'. Run 'gem search -rd fluent-plugin' to find plugins"
       end
     end
   end
-
-  Plugin = PluginClass.new
 end
diff --git a/lib/fluent/plugin/base.rb b/lib/fluent/plugin/base.rb
new file mode 100644
index 0000000000..a3c02ca74b
--- /dev/null
+++ b/lib/fluent/plugin/base.rb
@@ -0,0 +1,69 @@
+#
+# Fluentd
+#
+#    Licensed under the Apache License, Version 2.0 (the "License");
+#    you may not use this file except in compliance with the License.
+#    You may obtain a copy of the License at
+#
+#        http://www.apache.org/licenses/LICENSE-2.0
+#
+#    Unless required by applicable law or agreed to in writing, software
+#    distributed under the License is distributed on an "AS IS" BASIS,
+#    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+#    See the License for the specific language governing permissions and
+#    limitations under the License.
+#
+
+require 'fluent/plugin'
+require 'fluent/configurable'
+require 'fluent/plugin_id'
+require 'fluent/system_config'
+require 'fluent/log'
+
+module Fluent
+  module Plugin
+    class Base
+      include Configurable
+      include PluginId
+      include PluginLoggerMixin
+      include SystemConfigMixin
+
+      def initialize
+        super
+        @_plugin_running = nil
+      end
+
+      def configure(conf)
+        super
+      end
+
+      def start
+        @_plugin_running = true
+      end
+
+      def emits?
+        false # overwritten by Emitter mixin
+      end
+
+      def running?
+        @_plugin_running
+      end
+
+      def stop
+        @_plugin_running = false
+      end
+
+      def before_shutdown
+      end
+
+      def shutdown
+      end
+
+      def close
+      end
+
+      def terminate
+      end
+    end
+  end
+end
diff --git a/lib/fluent/plugin/buf_file.rb b/lib/fluent/plugin/buf_file.rb
index 21a015c16d..d61860b02e 100644
--- a/lib/fluent/plugin/buf_file.rb
+++ b/lib/fluent/plugin/buf_file.rb
@@ -14,225 +14,112 @@
 #    limitations under the License.
 #
 
-module Fluent
-  class FileBufferChunk < BufferChunk
-    def initialize(key, path, unique_id, mode="a+", symlink_path = nil)
-      super(key)
-      @path = path
-      @unique_id = unique_id
-      @file = File.open(@path, mode, DEFAULT_FILE_PERMISSION)
-      @file.binmode
-      @file.sync = true
-      @size = @file.stat.size
-      FileUtils.ln_sf(@path, symlink_path) if symlink_path
-    end
-
-    attr_reader :unique_id, :path
-
-    def <<(data)
-      @file.write(data)
-      @size += data.bytesize
-    end
-
-    def size
-      @size
-    end
-
-    def empty?
-      @size == 0
-    end
-
-    def close
-      stat = @file.stat
-      @file.close
-      if stat.size == 0
-        File.unlink(@path)
-      end
-    end
+require 'uri'
+require 'fileutils'
+require 'fluent/plugin/buffer'
+require 'fluent/plugin/buffer/file_chunk'
 
-    def purge
-      @file.close
-      File.unlink(@path) rescue nil  # TODO rescue?
-    end
+module Fluent::Plugin
+  class FileBuffer < Buffer
+    Fluent::Plugin.register_buffer('file', self)
 
-    def read
-      @file.pos = 0
-      @file.read
-    end
+    DEFAULT_CHUNK_BYTES_LIMIT = 8 * 1024 * 1024 # 8MB for memory
+    DEFAULT_TOTAL_BYTES_LIMIT = 64 * 1024 * 1024 * 1024 # 64GB
 
-    def open(&block)
-      @file.pos = 0
-      yield @file
-    end
+    @@buffer_paths = {}
 
-    def mv(path)
-      if Fluent.windows?
-        pos = @file.pos
-        @file.close
-        File.rename(@path, path)
-        @path = path
-        @file = File.open(@path, 'rb', DEFAULT_FILE_PERMISSION)
-        @file.sync = true
-        @size = @file.size
-        @file.pos = pos
-        @size = @file.stat.size
-      else
-        File.rename(@path, path)
-        @path = path
-      end
+    config_section :buffer, param_name: :buffer_config do
+      desc 'The path where buffer chunks are stored.'
+      config_param :path, :string, default: nil # buffer plugin refers system configuration and generate path for each plugin, if `@id` specified
+      desc 'If true, queued chunks are flushed at shutdown process.'
+      config_set_default :flush_at_shutdown, false
+      config_set_default :chunk_bytes_limit, DEFAULT_CHUNK_BYTES_LIMIT
+      config_set_default :total_bytes_limit, DEFAULT_TOTAL_BYTES_LIMIT
     end
-  end
+    # permission?
 
-  class FileBuffer < BasicBuffer
-    Plugin.register_buffer('file', self)
+    ##TODO: Buffer plugin cannot handle symlinks because new API @stage has many writing buffer chunks
+    ##      re-implement this feature on out_file, w/ enqueue_chunk(or generate_chunk) hook + chunk.path
+    # attr_accessor :symlink_path
 
-    @@buffer_paths = {}
-
-    def initialize
-      require 'uri'
+    def configure(plugin_id, conf)
       super
-
       @uri_parser = URI::Parser.new
-    end
-
-    desc 'The path where buffer chunks are stored.'
-    config_param :buffer_path, :string
-    desc 'If true, queued chunks are flushed at shutdown process.'
-    config_param :flush_at_shutdown, :bool, :default => false
 
-    # 'symlink_path' is currently only for out_file.
-    # That is the reason why this is not config_param, but attr_accessor.
-    # See: https://github.com/fluent/fluentd/pull/181
-    attr_accessor :symlink_path
+      buffer_path = @buffer_config.path
 
-    def configure(conf)
-      super
-
-      if @@buffer_paths.has_key?(@buffer_path)
-        raise ConfigError, "Other '#{@@buffer_paths[@buffer_path]}' plugin already use same buffer_path: type = #{conf['@type'] || conf['type']}, buffer_path = #{@buffer_path}"
-      else
-        @@buffer_paths[@buffer_path] = conf['@type'] || conf['type']
+      unless buffer_path
+        if !plugin_id || !system_config.buffer_dir_path
+          raise Fluent::ConfigError, "Cannot determine path for file buffer plugin!"
+        end
+        buffer_path = File.join(system_config.buffer_dir_path, plugin_id, 'buffer.*.log')
       end
 
-      if pos = @buffer_path.index('*')
-        @buffer_path_prefix = @buffer_path[0, pos]
-        @buffer_path_suffix = @buffer_path[(pos + 1)..-1]
-      else
-        @buffer_path_prefix = @buffer_path + "."
-        @buffer_path_suffix = ".log"
+      if @@buffer_paths.has_key?(buffer_path)
+        raise Fluent::ConfigError, "Duplicated buffer file path '#{buffer_path}'"
       end
+      @@buffer_paths[buffer_path] = self
 
+      @path = if buffer_path.index('*')
+                buffer_path
+              else
+                buffer_path + '.*.log'
+              end
+
+      @flush_at_shutdown = @buffer_config.flush_at_shutdown
     end
 
     def start
-      FileUtils.mkdir_p File.dirname(@buffer_path_prefix + "path"), :mode => DEFAULT_DIR_PERMISSION
+      FileUtils.mkdir_p File.dirname(@path), mode: DEFAULT_DIR_PERMISSION
       super
     end
 
-    # Dots are separator for many cases:
-    #   we should have to escape dots in keys...
-    PATH_MATCH = /^([-_.%0-9a-zA-Z]*)\.(b|q)([0-9a-fA-F]{1,32})$/
-
-    def new_chunk(key)
-      encoded_key = encode_key(key)
-      path, tsuffix = make_path(encoded_key, "b")
-      unique_id = tsuffix_to_unique_id(tsuffix)
-      FileBufferChunk.new(key, path, unique_id, "a+", @symlink_path)
-    end
-
     def resume
-      maps = []
-      queues = []
-
-      Dir.glob("#{@buffer_path_prefix}*#{@buffer_path_suffix}") {|path|
-        identifier_part = chunk_identifier_in_path(path)
-        if m = PATH_MATCH.match(identifier_part)
-          key = decode_key(m[1])
-          bq = m[2]
-          tsuffix = m[3]
-          timestamp = m[3].to_i(16)
-          unique_id = tsuffix_to_unique_id(tsuffix)
-
-          if bq == 'b'
-            chunk = FileBufferChunk.new(key, path, unique_id, "a+")
-            maps << [timestamp, chunk]
-          elsif bq == 'q'
-            chunk = FileBufferChunk.new(key, path, unique_id, "r")
-            queues << [timestamp, chunk]
-          end
+      stage = {}
+      queue = []
+
+      Dir.glob(@path) do |path|
+        m = metadata()
+        assumed_state = Fluent::Plugin::Buffer::FileChunk.assume_chunk_state(path)
+        mode = case assumed_state
+               when :staged then 'r+'
+               when :queued then 'r'
+               else
+                 raise "BUG: unexpected chunk state from assume_chunk_state: #{assumed_state}"
+               end
+        chunk = Fluent::Plugin::Buffer::FileChunk.new(m, path, mode)
+
+        case chunk.state
+        when :staged
+          stage[chunk.metadata] = chunk
+        when :queued, :blocked
+          queue << chunk
+        else
+          raise "BUG: unexpected chunk state '#{chunk.state}' for path '#{path}'"
         end
-      }
-
-      map = {}
-      maps.sort_by {|(timestamp,chunk)|
-        timestamp
-      }.each {|(timestamp,chunk)|
-        map[chunk.key] = chunk
-      }
-
-      queue = queues.sort_by {|(timestamp,chunk)|
-        timestamp
-      }.map {|(timestamp,chunk)|
-        chunk
-      }
-
-      return queue, map
-    end
+      end
 
-    def chunk_identifier_in_path(path)
-      pos_after_prefix = @buffer_path_prefix.length
-      pos_before_suffix = @buffer_path_suffix.length + 1 # from tail of path
+      queue.sort_by!{ |chunk| chunk.modified_at }
 
-      path.slice(pos_after_prefix..-pos_before_suffix)
+      return stage, queue
     end
 
-    def enqueue(chunk)
-      path = chunk.path
-      identifier_part = chunk_identifier_in_path(path)
-
-      m = PATH_MATCH.match(identifier_part)
-      encoded_key = m ? m[1] : ""
-      tsuffix = m[3]
-      npath = "#{@buffer_path_prefix}#{encoded_key}.q#{tsuffix}#{@buffer_path_suffix}"
-
-      chunk.mv(npath)
+    def generate_chunk(metadata)
+      Fluent::Plugin::Buffer::FileChunk.new(metadata, @path, 'w+')
     end
 
-    def before_shutdown(out)
-      if @flush_at_shutdown
-        synchronize do
-          @map.each_key {|key|
-            push(key)
-          }
-          while pop(out)
+    # overwrite to call `chunk.enqueued!`
+    def enqueue_chunk(metadata)
+      synchronize do
+        chunk = @stage.delete(metadata)
+        if chunk
+          chunk.synchronize do
+            chunk.enqueued!
           end
+          @queue << chunk
         end
+        nil
       end
     end
-
-    private
-
-    # Dots are separator for many cases:
-    #   we should have to escape dots in keys...
-    def encode_key(key)
-      @uri_parser.escape(key, /[^-_.a-zA-Z0-9]/n) # //n switch means explicit 'ASCII-8BIT' pattern
-    end
-
-    def decode_key(encoded_key)
-      @uri_parser.unescape(encoded_key)
-    end
-
-    def make_path(encoded_key, bq)
-      now = Time.now.utc
-      timestamp = ((now.to_i * 1000 * 1000 + now.usec) << 12 | rand(0xfff))
-      tsuffix = timestamp.to_s(16)
-      path = "#{@buffer_path_prefix}#{encoded_key}.#{bq}#{tsuffix}#{@buffer_path_suffix}"
-      return path, tsuffix
-    end
-
-    def tsuffix_to_unique_id(tsuffix)
-      # why *2 ? frsyuki said that I forgot why completely.
-      tsuffix.scan(/../).map {|x| x.to_i(16) }.pack('C*') * 2
-    end
   end
 end
diff --git a/lib/fluent/plugin/buf_memory.rb b/lib/fluent/plugin/buf_memory.rb
index 81d69256d8..8a9efb9cd3 100644
--- a/lib/fluent/plugin/buf_memory.rb
+++ b/lib/fluent/plugin/buf_memory.rb
@@ -14,98 +14,41 @@
 #    limitations under the License.
 #
 
-module Fluent
-  class MemoryBufferChunk < BufferChunk
-    def initialize(key, data='')
-      @data = data
-      @data.force_encoding('ASCII-8BIT')
-      now = Time.now.utc
-      u1 = ((now.to_i*1000*1000+now.usec) << 12 | rand(0xfff))
-      @unique_id = [u1 >> 32, u1 & 0xffffffff, rand(0xffffffff), rand(0xffffffff)].pack('NNNN')
-      super(key)
-    end
-
-    attr_reader :unique_id
+require 'fluent/plugin/buffer'
+require 'fluent/plugin/buffer/memory_chunk'
 
-    def <<(data)
-      data.force_encoding('ASCII-8BIT')
-      @data << data
-    end
+module Fluent::Plugin
+  class MemoryBuffer < Buffer
+    Fluent::Plugin.register_buffer('memory', self)
 
-    def size
-      @data.bytesize
-    end
-
-    def close
-    end
-
-    def purge
-    end
-
-    def read
-      @data
-    end
-
-    def open(&block)
-      StringIO.open(@data, &block)
-    end
-
-    # optimize
-    def write_to(io)
-      io.write @data
-    end
-
-    # optimize
-    def msgpack_each(&block)
-      u = Fluent::Engine.msgpack_factory.unpacker
-      u.feed_each(@data, &block)
-    end
-  end
-
-
-  class MemoryBuffer < BasicBuffer
-    Plugin.register_buffer('memory', self)
+    DEFAULT_CHUNK_BYTES_LIMIT = 8 * 1024 * 1024 # 8MB for memory
+    DEFAULT_TOTAL_BYTES_LIMIT = 512 * 1024 * 1024 # 512MB
 
     def initialize
       super
     end
 
-    desc 'If true, queued chunks are flushed at shutdown process. Otherwise queued chunks are discarded'
-    config_param :flush_at_shutdown, :bool, :default => true
-    # Overwrite default BasicBuffer#buffer_queue_limit
-    # to limit total memory usage upto 512MB.
-    config_set_default :buffer_queue_limit, 64
+    config_section :buffer, param_name: :buffer_config do
+      desc 'If true, queued chunks are flushed at shutdown process. Otherwise queued chunks are discarded'
+      config_set_default :flush_at_shutdown, true
+      config_set_default :chunk_bytes_limit, DEFAULT_CHUNK_BYTES_LIMIT
+      config_set_default :total_bytes_limit, DEFAULT_TOTAL_BYTES_LIMIT
+    end
 
-    def configure(conf)
+    def configure(plugin_id, conf)
       super
 
       unless @flush_at_shutdown
-        $log.warn "When flush_at_shutdown is false, buf_memory discards buffered chunks at shutdown."
-        $log.warn "Please confirm 'flush_at_shutdown false' configuration is correct or not."
-      end
-    end
-
-    def before_shutdown(out)
-      if @flush_at_shutdown
-        synchronize do
-          @map.each_key {|key|
-            push(key)
-          }
-          while pop(out)
-          end
-        end
+        @log.warn "Confirm whether `flush_at_shutdown false` is correct or not. Chunk contents of memory buffer will be discarded at shutdown without flushing."
       end
     end
 
-    def new_chunk(key)
-      MemoryBufferChunk.new(key)
-    end
-
     def resume
-      return [], {}
+      return {}, [] # stage, queue
     end
 
-    def enqueue(chunk)
+    def generate_chunk(metadata)
+      Fluent::Plugin::Buffer::MemoryChunk.new(metadata)
     end
   end
 end
diff --git a/lib/fluent/plugin/buffer.rb b/lib/fluent/plugin/buffer.rb
new file mode 100644
index 0000000000..aac5b3dfc5
--- /dev/null
+++ b/lib/fluent/plugin/buffer.rb
@@ -0,0 +1,353 @@
+#
+# Fluentd
+#
+#    Licensed under the Apache License, Version 2.0 (the "License");
+#    you may not use this file except in compliance with the License.
+#    You may obtain a copy of the License at
+#
+#        http://www.apache.org/licenses/LICENSE-2.0
+#
+#    Unless required by applicable law or agreed to in writing, software
+#    distributed under the License is distributed on an "AS IS" BASIS,
+#    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+#    See the License for the specific language governing permissions and
+#    limitations under the License.
+#
+
+require 'monitor'
+require 'fluent/configurable'
+require 'fluent/system_config'
+
+require 'fluent/plugin'
+
+module Fluent
+  module Plugin
+    class BufferError < StandardError; end
+    class BufferOverflowError < BufferError; end
+    class BufferChunkOverflowError < BufferError; end # A record size is larger than chunk size limit
+
+    # Buffer is to define an interface for all buffer plugins.
+
+    MINIMUM_APPEND_ATTEMPT_SIZE = 10
+
+    # Buffers are built on 2 element:
+    #  * stage: Array of chunks under writing, specified by metadata
+    #  * queue: FIFO list of chunks, which are already fulfilled, and to be flushed
+    #           Queue of a Buffer instance is shared by variations of metadata
+    class Buffer
+      include Configurable
+      include SystemConfigMixin
+      include MonitorMixin
+
+      config_section :buffer, param_name: :buffer_config, required: false, multi: false, final: true do
+        config_argument :type, :string, default: nil
+        config_param :chunk_bytes_limit, :size # default size is set by each buffer plugins
+        config_param :total_bytes_limit, :size
+
+        # If user specify this value and (chunk_size * queue_length) is smaller than total_size,
+        # then total_size is automatically configured to that value
+        config_param :queue_length_limit, :integer, default: nil
+
+        # optional new limitations
+        config_param :chunk_records_limit, :integer, default: nil
+
+        # TODO: pipeline mode? to flush ASAP after emit
+      end
+
+      Metadata = Struct.new(:timekey, :tag, :variables)
+
+      def initialize(logger)
+        super()
+        @log = logger
+
+        @chunk_bytes_limit = nil
+        @total_bytes_limit = nil
+        @queue_length_limit = nil
+        @chunk_records_limit = nil
+      end
+
+      def configure(plugin_id, conf)
+        super
+
+        @plugin_id = plugin_id # this is only something specified by user explicitly
+
+        if @buffer_config
+          @chunk_bytes_limit = @buffer_config.chunk_bytes_limit
+          @total_bytes_limit = @buffer_config.total_bytes_limit
+
+          @chunk_records_limit = @buffer_config.chunk_records_limit
+
+          @queue_length_limit = @buffer_config.queue_length_limit
+          if @queue_length_limit && @total_bytes_limit > @chunk_bytes_limit * @queue_length_limit
+            @total_bytes_limit = @chunk_bytes_limit * @queue_length_limit
+          end
+        else
+          @chunk_bytes_limit = self.class.const_get(:DEFAULT_CHUNK_BYTES_LIMIT)
+          @total_bytes_limit = self.class.const_get(:DEFAULT_TOTAL_BYTES_LIMIT)
+          @chunk_records_limit = nil
+        end
+      end
+
+      def start
+        super
+        @stage, @queue = resume
+        @queue.extend(MonitorMixin)
+
+        @queued_num = {} # metadata => int (number of queued)
+        @queue.each do |chunk|
+          @queued_num[chunk.metadata] ||= 0
+          @queued_num[chunk.metadata] += 1
+        end
+
+        @dequeued = {} # unique_id => chunk
+
+        @stage_size = @queue_size = 0
+        @metadata_list = [] # keys of @stage
+      end
+
+      def storable?
+        @total_size_limit > @stage_size + @queue_size
+      end
+
+      # def used?(ratio) # TODO: for back pressure feature
+      #   @total_size_limit * ratio > @stage_size + @queue_size
+      # end
+
+      def resume
+        raise NotImplementedError, "Implement this method in child class"
+      end
+
+      def generate_chunk(metadata)
+        raise NotImplementedError, "Implement this method in child class"
+      end
+
+      def metadata_list
+        synchronize do
+          @metadata_list.dup
+        end
+      end
+
+      def metadata(timekey: nil, tag: nil, key_value_pairs: {})
+        # TODO cache metadata not to new it
+        meta = if key_value_pairs.empty?
+                 Metadata.new(timekey, tag, [])
+               else
+                 variables = key_value_pairs.keys.sort.map{|k| key_value_pairs[k] }
+                 Metadata.new(timekey, tag, variables)
+               end
+        synchronize do
+          if i = @metadata_list.index(meta)
+            @metadata_list[i]
+          else
+            @metadata_list << meta
+            meta
+          end
+        end
+      end
+
+      # metadata MUST have consistent object_id for each variation
+      # data MUST be Array of serialized events
+      def emit(metadata, data)
+        return if data.size < 1
+        raise BufferOverflowError unless storable?
+
+        stored = false
+        data_size = data.size
+
+        # the case whole data can be stored in staged chunk: almost all emits will success
+        chunk = synchronize { @stage[metadata] ||= generate_chunk(metadata) }
+        chunk.synchronize do
+          begin
+            chunk.append(data)
+            unless size_over?(chunk)
+              chunk.commit
+              stored = true
+            end
+          ensure
+            chunk.rollback
+          end
+        end
+        return if stored
+
+        emit_step_by_step(metadata, data)
+      end
+
+      def staged_chunk_test(metadata) # block
+        synchronize do
+          chunk = @stage[metadata]
+          yield chunk
+        end
+      end
+
+      def queued?(metadata=nil)
+        synchronize do
+          return !@queue.empty? unless metadata
+          n = @queued_num[metadata]
+          n && n.nonzero?
+        end
+      end
+
+      def enqueue_chunk(metadata)
+        synchronize do
+          chunk = @stage.delete(metadata)
+          if chunk && !chunk.empty?
+            @queue << chunk
+            @queued_num[metadata] = @queued_num.fetch(metadata, 0) + 1
+          end
+          nil
+        end
+      end
+
+      def enqueue_all
+        synchronize do
+          @stage.keys.each do |metadata|
+            chunk = @stage.delete(metadata)
+            if chunk && !chunk.empty?
+              @queue << chunk
+              @queued_num[metadata] = @queued_num.fetch(metadata, 0) + 1
+            end
+          end
+        end
+      end
+
+      def dequeue_chunk
+        return nil if @queue.empty?
+        synchronize do
+          chunk = @queue.shift
+          return nil unless chunk # queue is empty
+          @dequeued[chunk.unique_id] = chunk
+          @queued_num[chunk.metadata] -= 1 # BUG if nil, 0 or subzero
+          chunk
+        end
+      end
+
+      def takeback_chunk(chunk_id)
+        synchronize do
+          chunk = @dequeued.delete(chunk_id)
+          return false unless chunk # already purged by other thread
+          @queue.unshift(chunk)
+          @queued_num[chunk.metadata] += 1 # BUG if nil
+          true
+        end
+      end
+
+      def purge_chunk(chunk_id)
+        synchronize do
+          chunk = @dequeued.delete(chunk_id)
+          begin
+            if chunk
+              chunk.purge
+              if !@stage[chunk.metadata] && (!@queued_num[chunk.metadata] || @queued_num[chunk.metadata] < 1)
+                @metadata_list.delete(chunk.metadata)
+              end
+            end
+          rescue => e
+            @log.error "failed to purge buffer chunk", chunk_id: chunk_id, error_class: e.class, error: e
+          end
+          nil
+        end
+      end
+
+      def queued_records
+        synchronize { @queue.reduce(0){|r, chunk| r + chunk.records } }
+      end
+
+      def clear!
+        synchronize do
+          until @queue.empty?
+            begin
+              @queue.shift.purge
+            rescue => e
+              @log.error "unexpected error while clearing buffer queue", error_class: e.class, error: e
+            end
+          end
+        end
+      end
+
+      def stop
+      end
+
+      def shutdown
+      end
+
+      def close
+        synchronize do
+          @dequeued.synchronize do
+            @dequeued.each_pair do |chunk_id, chunk|
+              chunk.close
+            end
+          end
+          @queue.synchronize do
+            until @queue.empty?
+              @queue.shift.close
+            end
+          end
+          @stage.each_pair do |metadata, chunk|
+            chunk.close
+          end
+        end
+      end
+
+      def terminate
+        @stage = @queue = nil
+      end
+
+      def size_over?(chunk)
+        chunk.size > @chunk_bytes_limit || (@chunk_records_limit && chunk.records > @chunk_records_limit)
+      end
+
+      def emit_step_by_step(metadata, data)
+        attempt_size = data.size / 3
+
+        synchronize do # critical section for buffer (stage/queue)
+          while data.size > 0
+            if attempt_size < MINIMUM_APPEND_ATTEMPT_SIZE
+              attempt_size = MINIMUM_APPEND_ATTEMPT_SIZE
+            end
+
+            chunk = @stage[metadata]
+            unless chunk
+              chunk = @stage[metadata] = generate_chunk(metadata)
+            end
+
+            chunk.synchronize do # critical section for chunk (chunk append/commit/rollback)
+              begin
+                empty_chunk = chunk.empty?
+
+                attempt = data.slice(0, attempt_size)
+                chunk.append(attempt)
+
+                if size_over?(chunk)
+                  chunk.rollback
+
+                  if attempt_size <= MINIMUM_APPEND_ATTEMPT_SIZE
+                    if empty_chunk # record is too large even for empty chunk
+                      raise BufferChunkOverflowError, "minimum append butch exceeds chunk bytes limit"
+                    end
+                    # no more records for this chunk -> enqueue -> to be flushed
+                    enqueue_chunk(metadata) # `chunk` will be removed from stage
+                    attempt_size = data.size # fresh chunk may have enough space
+                  else
+                    # whole data can be processed by twice operation
+                    #  ( by using apttempt /= 2, 3 operations required for odd numbers of data)
+                    attempt_size = (attempt_size / 2) + 1
+                  end
+
+                  next
+                end
+
+                chunk.commit
+                data.slice!(0, attempt_size)
+                # same attempt size
+                nil # discard return value of data.slice!() immediately
+              ensure
+                chunk.rollback
+              end
+            end
+          end
+        end
+        nil
+      end # emit_step_by_step
+    end
+  end
+end
diff --git a/lib/fluent/plugin/buffer/chunk.rb b/lib/fluent/plugin/buffer/chunk.rb
new file mode 100644
index 0000000000..239f6d162d
--- /dev/null
+++ b/lib/fluent/plugin/buffer/chunk.rb
@@ -0,0 +1,121 @@
+#
+# Fluentd
+#
+#    Licensed under the Apache License, Version 2.0 (the "License");
+#    you may not use this file except in compliance with the License.
+#    You may obtain a copy of the License at
+#
+#        http://www.apache.org/licenses/LICENSE-2.0
+#
+#    Unless required by applicable law or agreed to in writing, software
+#    distributed under the License is distributed on an "AS IS" BASIS,
+#    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+#    See the License for the specific language governing permissions and
+#    limitations under the License.
+#
+
+require 'monitor'
+
+module Fluent
+  module Plugin
+    class Buffer
+      class Chunk
+        include MonitorMixin
+
+        # Chunks has 2 part:
+        # * metadata: contains metadata which should be restored after resume (if possible)
+        #             v: [metadata_variable, ...] (required)
+        #             t: tag as string (optional)
+        #             k: time slice key (optional)
+        #
+        #             id: unique_id of chunk (*)
+        #             r: number of records (*)
+        #             c: created_at as unix time (*)
+        #             m: modified_at as unix time (*)
+        #              (*): fields automatically injected by chunk itself
+        # * data: binary data, combined records represented as String, maybe compressed
+
+        # NOTE: keys of metadata are named with a single letter
+        #       to decread bytesize of metadata I/O
+
+        # TODO: CompressedPackedMessage of forward protocol?
+
+        def initialize(metadata)
+          super()
+          @unique_id = generate_unique_id
+          @metadata = metadata
+
+          @records = 0
+          @created_at = Time.now
+          @modified_at = Time.now
+        end
+
+        attr_reader :unique_id, :metadata, :created_at, :modified_at
+
+        def generate_unique_id
+          now = Time.now.utc
+          u1 = ((now.to_i * 1000 * 1000 + now.usec) << 12 | rand(0xfff))
+          [u1 >> 32, u1 & 0xffffffff, rand(0xffffffff), rand(0xffffffff)].pack('NNNN')
+        end
+
+        # data is array of formatted record string
+        def append(data)
+          raise NotImplementedError, "Implement this method in child class"
+        end
+
+        def commit
+          raise NotImplementedError, "Implement this method in child class"
+        end
+
+        def rollback
+          raise NotImplementedError, "Implement this method in child class"
+        end
+
+        def size
+          raise NotImplementedError, "Implement this method in child class"
+        end
+
+        def records
+          raise NotImplementedError, "Implement this method in child class"
+        end
+
+        def empty?
+          size == 0
+        end
+
+        def close
+          raise NotImplementedError, "Implement this method in child class"
+        end
+
+        def purge
+          raise NotImplementedError, "Implement this method in child class"
+        end
+
+        def read
+          raise NotImplementedError, "Implement this method in child class"
+        end
+
+        def open(&block)
+          raise NotImplementedError, "Implement this method in child class"
+        end
+
+        ### TODO: fixit
+        def write_to(io)
+          open {|i|
+            FileUtils.copy_stream(i, io)
+          }
+        end
+
+        def msgpack_each(&block)
+          open {|io|
+            u = MessagePack::Unpacker.new(io)
+            begin
+              u.each(&block)
+            rescue EOFError
+            end
+          }
+        end
+      end
+    end
+  end
+end
diff --git a/lib/fluent/plugin/buffer/file_chunk.rb b/lib/fluent/plugin/buffer/file_chunk.rb
new file mode 100644
index 0000000000..c7dd022fe5
--- /dev/null
+++ b/lib/fluent/plugin/buffer/file_chunk.rb
@@ -0,0 +1,321 @@
+#
+# Fluentd
+#
+#    Licensed under the Apache License, Version 2.0 (the "License");
+#    you may not use this file except in compliance with the License.
+#    You may obtain a copy of the License at
+#
+#        http://www.apache.org/licenses/LICENSE-2.0
+#
+#    Unless required by applicable law or agreed to in writing, software
+#    distributed under the License is distributed on an "AS IS" BASIS,
+#    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+#    See the License for the specific language governing permissions and
+#    limitations under the License.
+#
+
+require 'fluent/plugin/buffer/chunk'
+require 'fluent/env'
+
+require 'msgpack'
+
+module Fluent
+  module Plugin
+    class Buffer
+      class FileChunk < Chunk
+        ### buffer path user specified : /path/to/directory/user_specified_prefix.*.log
+        ### buffer chunk path          : /path/to/directory/user_specified_prefix.b513b61c9791029c2513b61c9791029c2.log
+        ### buffer chunk metadata path : /path/to/directory/user_specified_prefix.b513b61c9791029c2513b61c9791029c2.log.meta
+
+        # NOTE: Old style buffer path of time sliced output plugins had a part of key: prefix.20150414.b513b61...suffix
+        #       But this part is not used for any purpose. (Now metadata is used instead.)
+
+        # state: b/q - 'b'(on stage), 'q'(enqueued)
+        # path_prefix: path prefix string, ended with '.'
+        # path_suffix: path suffix string, like '.log' (or any other user specified)
+
+        attr_reader :path, :state
+
+        # mode: 'w+'(newly created/on stage), 'r+'(already exists/on stage), 'r'(already exists/enqueued)
+        def initialize(metadata, path, mode, perm=DEFAULT_FILE_PERMISSION) # TODO: DEFAULT_FILE_PERMISSION is obsolete
+          super
+
+          # state: staged/queued/closed
+          #   blocked is internal status for chunks waiting to be enqueued
+
+          @state = nil
+
+          case mode
+          when 'w+' # newly created / on stage
+            @path = generate_stage_chunk_path(path)
+            @meta_path = @path + '.meta'
+            @chunk = File.open(@path, mode, perm)
+            @chunk.sync = true
+            @chunk.binmode
+            @meta = File.open(@meta_path, 'w', perm)
+            @meta.sync = true
+            @meta.binmode
+
+            @state = :staged
+            @bytesize = 0
+            @commit_position = @chunk.pos # must be 0
+            @adding_bytes = 0
+            @adding_records = 0
+
+          when 'r+' # already exists / on stage
+            @path = path
+            @meta_path = @path + '.meta'
+
+            @meta = nil
+            # staging buffer chunk without metadata is classic buffer chunk file
+            # and it should be enqueued immediately
+            if File.exist?(@meta_path)
+              @chunk = File.open(@path, mode)
+              @chunk.sync = true
+              @chunk.seek(0, IO::SEEK_END)
+              @chunk.binmode
+
+              @meta = File.open(@meta_path, 'r+')
+              @meta.sync = true
+              restore_metadata(@meta.read)
+              @meta.seek(0, IO::SEEK_SET)
+              @meta.binmode
+
+              @state = :staged
+              @bytesize = @chunk.size
+              @commit_position = @chunk.pos
+              @adding_bytes = 0
+              @adding_records = 0
+            else
+              # classic buffer chunk - read only chunk
+              @chunk = File.open(@path, 'r')
+              @chunk.binmode
+              @state = :queued
+              @bytesize = @chunk.size
+
+              restore_metadata_partially(@chunk)
+
+              @unique_id = unique_id_from_path(@path) || @unique_id
+            end
+
+          when 'r'  # already exists / enqueued
+            @path = path
+            @chunk = File.open(@path, mode)
+            @chunk.binmode
+            @bytesize = @chunk.size
+
+            @meta_path = @path + '.meta'
+            if File.readable?(@meta_path)
+              restore_metadata(File.open(@meta_path){|f| f.binmode; f.read })
+            else
+              restore_metadata_partially(@chunk)
+            end
+            @state = :queued
+          end
+        end
+
+        # MUST be called in critical section
+        def append(data)
+          raise "BUG: appending to non-staged chunk, now '#{@state}'" unless @state == :staged
+
+          adding = data.join.force_encoding('ASCII-8BIT')
+          @chunk.write adding
+
+          @adding_bytes += adding.bytesize
+          @adding_records += data.size
+          write_metadata(try_update: true) # of course, this operation may fail
+
+          true
+        end
+
+        # MUST be called in critical section
+        def commit
+          @commit_position = @chunk.pos
+          @records += @adding_records
+          @bytesize += @adding_bytes
+          @modified_at = Time.now
+
+          @adding_bytes = @adding_records = 0
+          true
+        end
+
+        # MUST be called in critical section
+        def rollback
+          if @chunk.pos == @commit_position
+            @chunk.seek(@commit_position, IO::SEEK_SET)
+            @chunk.truncate(@commit_position)
+          end
+          @adding_bytes = @adding_records = 0
+          true
+        end
+
+        def size
+          @bytesize
+        end
+
+        def records
+          @records + @adding_records
+        end
+
+        def empty?
+          @bytesize == 0
+        end
+
+        def close
+          @state = :closed
+          size = @chunk.size
+          @chunk.close
+          @meta.close
+          if size == 0
+            File.unlink(@path, @meta_path)
+          end
+        end
+
+        # MUST be called in critical section
+        def purge
+          @state = :closed
+          @chunk.close
+          @meta.close
+          File.unlink(@path, @meta_path)
+        end
+
+        def read
+          @chunk.seek(0, IO::SEEK_SET)
+          @chunk.read
+        end
+
+        def open(&block) # TODO: check whether used or not
+          @chunk.seek(0, IO::SEEK_SET)
+          val = yield @chunk
+          @chunk.seek(0, IO::SEEK_END) if @state == :staged
+          val
+        end
+
+        ### TODO: fixit
+        def write_to(io)
+          open {|i|
+            FileUtils.copy_stream(i, io)
+          }
+        end
+
+        ### TODO: fixit
+        def msgpack_each(&block)
+          open {|io|
+            u = MessagePack::Unpacker.new(io)
+            begin
+              u.each(&block)
+            rescue EOFError
+            end
+          }
+        end
+
+        # methods for FileBuffer operations
+
+        def self.assume_chunk_state(path)
+          if /\.(b|q)([0-9a-f]+)\.[^\/]*\Z/n =~ path # //n switch means explicit 'ASCII-8BIT' pattern
+            $1 == 'b' ? :staged : :queued
+          else
+            :queued
+          end
+        end
+
+        def generate_stage_chunk_path(path)
+          pos = path.index('*')
+          raise "BUG: buffer chunk path on stage MUST have '*'" unless pos
+
+          prefix = path[0...pos]
+          suffix = path[(pos+1)..-1]
+
+          chunk_id = @unique_id.unpack('N*').map{|n| n.to_s(16)}.join
+          state = 'b'
+          "#{prefix}#{state}#{chunk_id}#{suffix}"
+        end
+
+        def generate_queued_chunk_path(path)
+          chunk_id = @unique_id.unpack('N*').map{|n| n.to_s(16)}.join
+          if pos = path.index('b' + chunk_id)
+            path.sub('b' + chunk_id, 'q' + chunk_id)
+          else # for unexpected cases (ex: users rename files while opened by fluentd)
+            path + 'q' + chunk_id + '.log'
+          end
+        end
+
+        # used only for queued buffer path
+        def unique_id_from_path(path)
+          if /\.(b|q)([0-9a-f]+)\.[^\/]*\Z/n =~ path # //n switch means explicit 'ASCII-8BIT' pattern
+            return $2.scan(/../).map{|x| x.to_i(16) }.pack('C*')
+          end
+          nil
+        end
+
+        def restore_metadata(bindata)
+          # Any input errors are ignored
+          data = MessagePack.unpack(bindata, symbolize_keys: true) rescue {}
+
+          @unique_id = data[:id] || unique_id_from_path(@path) || @unique_id
+          @records = data[:r] || 0
+          @created_at = Time.at(data.fetch(:c, Time.now.to_i))
+          @modified_at = Time.at(data.fetch(:m, Time.now.to_i))
+
+          @metadata.timekey = data[:timekey]
+          @metadata.tag = data[:tag]
+          @metadata.variables = data.fetch(:variables, [])
+        end
+
+        def restore_metadata_partially(chunk)
+          @unique_id = unique_id_from_path(chunk.path) || @unique_id
+          @records = 0
+          @created_at = chunk.birthtime rescue chunk.ctime # birthtime isn't supported on Windows
+          @modified_at = chunk.mtime
+
+          @metadata.timekey = nil
+          @metadata.tag = nil
+          @metadata.variables = []
+        end
+
+        def write_metadata(try_update: false)
+          data = @metadata.to_h.merge({
+              id: @unique_id,
+              r: (try_update ? @records + @adding_records : @records),
+              c: @created_at.to_i,
+              m: (try_update ? Time.now.to_i : @modified_at.to_i)
+          })
+          @meta.seek(0, IO::SEEK_SET)
+          @meta.truncate(0)
+          @meta.write MessagePack.pack(data)
+        end
+
+        def enqueued!
+          return unless @state == :staged
+
+          new_chunk_path = generate_queued_chunk_path(@path)
+          new_meta_path = new_chunk_path + '.meta'
+
+          write_metadata # re-write metadata w/ finalized records
+
+          file_rename(@chunk, @path, new_chunk_path, ->(size){ @size = size })
+          @path = new_chunk_path
+
+          file_rename(@meta, @meta_path, new_meta_path)
+          @meta_path = new_meta_path
+
+          @state = :queued
+        end
+
+        def file_rename(file, old_path, new_path, callback)
+          if Fluent.windows?
+            pos = file.pos
+            file.close
+            File.rename(old_path, new_path)
+            file = File.open(new_path, 'rb', DEFAULT_FILE_PERMISSION)
+            file.sync = true
+            file.pos = pos
+          else
+            file.rename(new_path)
+          end
+          callback.call(file.size) if callback
+        end
+      end
+    end
+  end
+end
diff --git a/lib/fluent/plugin/buffer/memory_chunk.rb b/lib/fluent/plugin/buffer/memory_chunk.rb
new file mode 100644
index 0000000000..e6b743f2d0
--- /dev/null
+++ b/lib/fluent/plugin/buffer/memory_chunk.rb
@@ -0,0 +1,110 @@
+#
+# Fluentd
+#
+#    Licensed under the Apache License, Version 2.0 (the "License");
+#    you may not use this file except in compliance with the License.
+#    You may obtain a copy of the License at
+#
+#        http://www.apache.org/licenses/LICENSE-2.0
+#
+#    Unless required by applicable law or agreed to in writing, software
+#    distributed under the License is distributed on an "AS IS" BASIS,
+#    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+#    See the License for the specific language governing permissions and
+#    limitations under the License.
+#
+
+require 'fluent/plugin/buffer/chunk'
+
+require 'fileutils'
+require 'msgpack'
+
+module Fluent
+  module Plugin
+    class Buffer
+      class MemoryChunk < Chunk
+        def initialize(metadata)
+          super
+          @chunk = ''.force_encoding('ASCII-8BIT')
+          @chunk_bytes = 0
+          @adding_bytes = 0
+          @adding_records = 0
+        end
+
+        # MUST be called in critical section
+        def append(data)
+          adding = data.join.force_encoding('ASCII-8BIT')
+          @chunk << adding
+          @adding_bytes += adding.bytesize
+          @adding_records += data.size
+          true
+        end
+
+        # MUST be called in critical section
+        def commit
+          @records += @adding_records
+          @chunk_bytes += @adding_bytes
+
+          @adding_bytes = @adding_records = 0
+          true
+        end
+
+        # MUST be called in critical section
+        def rollback
+          @chunk.slice!(@chunk_bytes, @adding_bytes)
+          @adding_bytes = @adding_records = 0
+          true
+        end
+
+        def size
+          @chunk_bytes + @adding_bytes
+        end
+
+        def records
+          @records + @adding_records
+        end
+
+        def empty?
+          @chunk.empty?
+        end
+
+        def close
+          true
+        end
+
+        # MUST be called in critical section
+        def purge
+          @chunk = ''.force_encoding("ASCII-8BIT")
+          @chunk_bytes = @adding_bytes = @adding_records = 0
+          true
+        end
+
+        def read
+          @chunk
+        end
+
+        def open(&block)
+          StringIO.open(@chunk, &block)
+        end
+
+        ### TODO: fixit
+        def write_to(io)
+          open {|i|
+            FileUtils.copy_stream(i, io)
+          }
+        end
+
+        ### TODO: fixit
+        def msgpack_each(&block)
+          open {|io|
+            u = MessagePack::Unpacker.new(io)
+            begin
+              u.each(&block)
+            rescue EOFError
+            end
+          }
+        end
+      end
+    end
+  end
+end
diff --git a/lib/fluent/plugin/buffered_output.rb b/lib/fluent/plugin/buffered_output.rb
new file mode 100644
index 0000000000..305af48eb0
--- /dev/null
+++ b/lib/fluent/plugin/buffered_output.rb
@@ -0,0 +1,530 @@
+#
+# Fluentd
+#
+#    Licensed under the Apache License, Version 2.0 (the "License");
+#    you may not use this file except in compliance with the License.
+#    You may obtain a copy of the License at
+#
+#        http://www.apache.org/licenses/LICENSE-2.0
+#
+#    Unless required by applicable law or agreed to in writing, software
+#    distributed under the License is distributed on an "AS IS" BASIS,
+#    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+#    See the License for the specific language governing permissions and
+#    limitations under the License.
+#
+
+require 'fluent/plugin/output'
+
+module Fluent
+  module Plugin
+    class BufferedOutput < Output
+      config_param :tag_chunked, :bool, default: false
+
+      config_section :buffer, param_name: :buffer_config, required: false, multi: false, final: true do
+        config_set_default :type, "memory"
+
+        # Buffer and its chunk configurations are defined in each buffer plugins
+        # This plugin defines options for how to flush/retry
+
+        config_param :flush_at_shutdown, :bool # default should be set by Buffer plugins
+
+        desc 'The interval between data flushes.'
+        config_param :flush_interval, :time, default: 60
+        config_param :flush_thread_interval, :float, default: 1.0
+        config_param :flush_burst_interval, :float, default: 1.0
+        config_param :flush_immediately, :bool, default: false
+
+        desc 'The number of threads to flush the buffer.'
+        config_param :flush_threads, :integer, default: 1
+
+        desc 'If true, plugins ignore retry_limit_* options and will retry flushing forever.'
+        config_param :retry_forever, :bool, default: false
+        desc 'The maximum seconds to retry to flush while failing until plugins discard buffer chunks.'
+        config_param :retry_limit_time, :time, default: 72 * 60 * 60 # 72hours -- 17 times exponential backoff
+        desc 'The maximum times to retry to flush while failing until plugins discard buffer chunks.'
+        config_param :retry_limit_times, :integer, default: nil
+
+        # Percentage of retry_limit_time to swtich to use secondary
+        #  expornential backoff sequence will be initialized at the time of this threshold
+        config_param :retry_secondary_threshold, :integer, default: 80
+
+        config_param :retry_type, :enum, list: [:expbackoff, :periodic], default: :expbackoff
+        ### Periodic -> fixed :retry_wait
+        ### Exponencial backoff: k is number of retry times
+        # c: constant factor, @retry_wait
+        # b: base factor, @retry_backoff_base
+        # k: times
+        # total retry time: c + c * b^1 + (...) + c*b^k = c*b^(k+1) - 1
+        desc 'The constant factor of exponencial backoff for retries.'
+        config_param :retry_wait, :time, default: 1 # initial retry wait time & constant factor of exponencial backoff
+        desc 'The base number of exponencial backoff for retries.'
+        config_param :retry_backoff_base, :float, default: 2 # base of exponencial backoff
+        desc 'The maximum interval seconds for exponencial backoff between retries while failing.'
+        config_param :retry_max_interval, :time, default: nil
+      end
+
+      config_section :secondary, param_name: :secondary_config, required: false, multi: false, final: true do
+        # to check there're <secondary> section at most once
+
+        config_section :buffer, required: false, multi: false do
+          # this section must not be specified in configuration files
+        end
+      end
+
+      def format(tag, time, record)
+        raise NotImplementedError, "BUG: buffered output plugins MUST implement this method"
+      end
+
+      ### Implement try_write if plugin does commit_flush under its own responsibility
+      # def try_write(chunk)
+
+      def write(chunk)
+        raise NotImplementedError, "BUG: buffered output plugins MUST implement this method"
+      end
+
+      def configure(conf)
+        super
+
+        c = @buffer_config
+
+        @buffer = Fluent::Plugin.new_buffer(c.type)
+        @buffer.configure(conf)
+
+        @flush_at_shutdown = c.flush_at_shutdown
+
+        @flush_interval = c.flush_interval
+        @flush_thread_interval = c.flush_thread_interval
+        @flush_burst_interval = c.flush_burst_interval
+        @flush_immediately = c.flush_immediately
+
+        @flush_threads = c.flush_threads
+
+        if @secondary_config
+          if @secondary_config.buffer
+            raise Fluent::ConfigError, "invalid <buffer> section configured in <secondary> section"
+          end
+          subconf = conf.elements.select {|e| e.name == 'secondary' }.first
+          # assume that secondary plugin is a same plugin to primary one if type isn't specified
+          subtype = subconf['@type'] || subconf['type'] || conf['@type'] || conf['type']
+          @secondary = Plugin.new_output(subtype)
+          @secondary.router = router
+          @secondary.configure(subconf)
+          @secondary.check_as_secondary(self)
+        end
+
+        @delayed_purge_enabled = false
+        @delayed_purge_timeout = nil
+      end
+
+      def enable_delayed_purge(timeout:)
+        unless self.respond_to?(:try_write)
+          raise Fluent::ConfigError, "BUG: try_write method required to enable delayed purge"
+        end
+        @delayed_purge_enabled = true
+        @delayed_purge_timeout = timeout
+      end
+
+      def check_as_secondary(primary)
+        if primary.class != self.class
+          log.warn "type of secondary output should be same as primary output", primary: primary.class.to_s, secondary: self.class.to_s
+        end
+      end
+
+      def start
+        @num_errors = 0
+        @emit_count = 0
+
+        @cached_metadata = []
+        @cached_metadata_mutex = Mutex.new
+
+        @retry = nil # state machine
+        @retry_mutex = Mutex.new
+
+        if @delayed_purge_timeout
+          @dequeued_chunks = [] # for delayed purge: array of DequeuedChunkInfo
+          @dequeued_chunks_mutex = Mutex.new
+        end
+
+        # PluginSupport::Thread stops ealier than expected for OutputThread, which works for `before_shutdown` after `stop`
+        @writers = (1..@flush_threads).map{ OutputThread.new(self, @log) }
+
+        @buffer.start
+        @secondary.start if @secondary
+
+        @writers.each {|writer| writer.start }
+        @writer_current_position = 0
+        @writers_size = @writers.size
+      end
+
+      def stop
+        super
+        @writers.each {|writer| writer.stop }
+        @secondary.stop if @secondary
+        @buffer.stop
+      end
+
+      def before_shutdown
+        super
+        if @flush_at_shutdown
+          force_flush
+        end
+      end
+
+      def shutdown
+        super
+        @writers.each {|writer| writer.shutdown }
+        @secondary.shutdown if @secondary
+        @buffer.shutdown
+      end
+
+      def close
+        super
+        @writers.each {|writer| writer.close }
+        @secondary.close if @secondary
+        @buffer.close
+      end
+
+      def terminate
+        super
+        @writers.each {|writer| writer.terminate }
+        @secondary.terminate if @secondary
+        @buffer.terminate
+      end
+
+      def metadata(tag)
+        @tag_chunked ? @buffer.metadata(tag: tag) : @buffer.metadata()
+      end
+
+      def emit(tag, es)
+        metalist = handle_stream(tag, es)
+        if @flush_immediately
+          matalist.each do |meta|
+            @buffer.enqueue_chunk(meta)
+          end
+        end
+        if !@retry && metalist.reduce(false){|r,m| r || @buffer.enqueued?(m) }
+          submit_flush
+        end
+      end
+
+      def handle_stream(tag, es)
+        meta = metadata(tag)
+        @emit_count += 1
+        data = format_stream(tag, es)
+        @buffer.emit(meta, data)
+        [meta]
+      end
+
+      def format_stream(tag, es)
+        out = ''
+        es.each do |time, record|
+          out << format(tag, time, record)
+        end
+        out
+      end
+
+      def submit_flush
+        # Without locks: it is rough but enough to select "next" writer selection
+        @writer_current_position = (@writer_current_position + 1) % @writers_size
+        @writers[@writer_current_position].submit_flush
+      end
+
+      def commit_write(chunk_id)
+        if @delayed_purge_enabled
+          @dequeued_chunks_mutex.synchronize do
+            @dequeued_chunks.delete_if { |info| info.chunk_id == chunk_id }
+          end
+        else
+          @buffer.purge_chunk(chunk_id)
+        end
+        @retry_mutex.synchronize do
+          if @retry # success to flush chunks
+            log.warn "retry succeeded.", plugin_id: plugin_id
+            @retry = nil
+            @num_errors = 0
+          end
+        end
+      end
+
+      def try_rollback_write
+        @dequeued_chunks_mutex.synchronize do
+          now = Time.now
+          while !@dequeued_chunks.empty? && @dequeued_chunks.first.time + @delayed_purge_timeout > now
+            info = @delayed_purge_timeout.shift
+            if @buffer.takeback_chunk(info.chunk_id)
+              log.warn "failed to flush chunk, timeout to commit.", plugin_id: plugin_id, chunk_id: chunk_id, flushed_at: info.time
+              log.warn_backtrace e.backtrace
+            end
+          end
+        end
+      end
+
+      def enqueue_buffer(force: false, test: ->(chunk){ chunk.created_at + @flush_interval > Time.now })
+        if force
+          @buffer.enqueue_all
+        else
+          metalist = @buffer.metadata_list
+          metalist.each do |meta|
+            if @buffer.staged_chunk_test(meta, &test)
+              @buffer.enqueue_chunk(meta)
+            end
+          end
+        end
+      end
+
+      def force_flush
+        enqueue_buffer(force: true)
+        submit_flush
+      end
+
+      def next_flush_time
+        if @buffer.queued?
+          @retry_mutex.synchronize do
+            @retry ? @retry.next_time : Time.now + @flush_burst_interval
+          end
+        else
+          Time.now + @flush_thread_interval
+        end
+      end
+
+      def try_flush
+        enqueue_buffer unless @buffer.queued?
+        return unless @buffer.queued?
+
+        chunk = @buffer.dequeue_chunk
+        return unless chunk
+
+        output = self
+        if @retry_mutex.synchronize{ @retry && @retry.secondary? }
+          output = @secondary
+        end
+        begin
+          if @delayed_purge_enabled && output.respond_to?(:try_write) # secondary plugin may not support try_write method
+            output.try_write(chunk)
+            @dequeued_chunks_mutex.synchronize do
+              @dequeued_chunks << DequeuedChunkInfo.new(chunk.unique_id, Time.now)
+            end
+          else
+            # output plugin without delayed purge
+            chunk_id = chunk.unique_id
+            output.write(chunk)
+            commit_write(chunk_id)
+          end
+        rescue => e
+          @retry_mutex.synchronize do
+            if @retry
+              @retry.step
+              @num_errors = @retry.times
+              if @retry.limit?
+                records = @buffer.queued_records
+                log.error "failed to flush the buffer, and hit limit for retries. dropping all chunks in buffer queue.", records: records, error_class: e.class, error: e, plugin_id: plugin_id
+                log.error_backtrace e.backtrace
+                @buffer.clear!
+                @retry = nil
+              elsif !@retry.secondary?
+                log.warn "failed to flush the buffer.", next_retry: @retry.next_time, error_class: e.class, error: e, plugin_id: plugin_id
+                log.warn_backtrace e.backtrace
+              else # secondary
+                log.warn "failed to flush the buffer with secondary output.", next_retry: @retry.next_time, error_class: e.class, error: e, plugin_id: plugin_id
+                log.warn_backtrace e.backtrace
+              end
+            else
+              @retry = RetryStateMachine.create(@buffer_config, @secondary)
+              @num_errors = @retry.times # == 1
+              log.warn "failed to flush the buffer.", next_retry: @retry.next_time, error_class: e.class, error: e, plugin_id: plugin_id
+              log.warn_backtrace e.backtrace
+            end
+          end
+        end
+      end
+
+      DequeuedChunkInfo = Struct.new(:chunk_id, :time)
+
+      class RetryStateMachine
+        attr_reader :next_time, :times
+
+        def self.create(conf, secondary)
+          case conf.retry_type
+          when :expbackoff
+            ExponencialBackOffRetry.new(conf, secondary)
+          when :periodic
+            PeriodicRetry.new(conf, secondary)
+          else
+            raise "BUG: unknown retry_type specified: '#{conf.retry_type}'"
+          end
+        end
+
+        def initialize(conf, secondary)
+          @start = Time.now
+          @times = 1
+          @next_time = nil # should be initialized for first retry by child class
+
+          @forever = conf.retry_forever
+          @limit_time = Time.now + conf.retry_limit_time
+          @limit_times = conf.retry_limit_times
+
+          @current = :primary
+          @secondary = secondary
+          @secondary_threshold = conf.retry_secondary_threshold
+          if @secondary
+            @secondary_transition = Time.now + @limit_time * @secondary_threshold / 100
+            @secondary_transition_times = nil
+          end
+        end
+
+        def calc_next_time
+          if @forever || !@secondary # primary
+            naive = naive_next_time(@times)
+            if naive >= @limit_time
+              @limit_time
+            else
+              naive
+            end
+          elsif @current == :primary && @secondary
+            naive = naive_next_time(@times)
+            if naive >= @secondary_transition
+              @secondary_transition
+            else
+              naive
+            end
+          elsif @current == :secondary
+            naive = naive_next_time(@times - @secondary_transition_times)
+            if naive >= @limit_time
+              @limit_time
+            else
+              naive
+            end
+          else
+            raise "BUG: it's out of design"
+          end
+        end
+
+        def naive_next_time(retry_times)
+          raise NotImplementedError
+        end
+
+        def secondary?
+          @secondary && @current == :secondary
+        end
+
+        def step(next_time)
+          @times += 1
+          @next_time = calc_next_time
+          if @secondary && @next_time >= @secondary_transition
+            @current = :secondary
+            @secondary_transition_times = @times - 1
+          end
+        end
+
+        def limit?
+          if @forever
+            false
+          else
+            @next_time >= @limit_time || @times >= @limit_times
+          end
+        end
+      end
+
+      class ExponencialBackOffRetry < RetryStateMachine
+        def initialize(conf, secondary)
+          super
+          @constant_factor = conf.retry_wait
+          @backoff_base = conf.retry_backoff_base
+          @max_interval = conf.retry_max_interval
+
+          @next_time = Time.now + @constant_factor
+        end
+
+        def naive_next_time(retry_next_times)
+          interval = @constant_factor * ( @backoff_base ** ( retry_next_times - 1 ) )
+          if @max_interval && interval > @max_interval
+            @max_interval
+          else
+            ### why rand only for wait.finite?
+            # retry_wait = wait.finite? ? wait + (rand * (wait / 4.0) - (wait / 8.0)) : wait
+            interval
+          end
+        end
+      end
+
+      class PeriodicRetry < RetryStateMachine
+        def initialize(conf, secondary)
+          super
+          @retry_wait = conf.retry_wait
+          @next_time = Time.now + @retry_wait
+        end
+
+        def naive_next_time(retry_next_times)
+          @retry_wait
+        end
+      end
+
+      class OutputThread
+        def initialize(output, log)
+          @output = output
+          @log = log
+          # If the given clock_id is not supported, Errno::EINVAL is raised.
+          @clock = Process::CLOCK_MONOTONIC rescue Process::CLOCK_MONOTONIC_RAW
+        end
+
+        def start
+          @finish = false
+          @next_time = Process.clock_gettime(@clock) + 1.0
+          @thread = Thread.new(&method(:run))
+        end
+
+        def stop
+        end
+
+        def shutdown
+          @finish = true
+          @thread.run
+          @thread.join
+        end
+
+        def close
+        end
+
+        def terminate
+          @thread = nil
+          @finish = nil
+          @next_time = nil
+        end
+
+        def submit_flush
+          @next_time = 0
+          @thread.run
+        end
+
+        def run
+          Thread.current.abort_on_exception = true
+          begin
+            until @finish
+              time = Process.clock_gettime(clock_id)
+              interval = @next_time - time
+
+              if @delayed_purge_enabled && @dequeued_chunks_mutex.synchronize{ !@dequeued_chunks.empty? }
+                @output.try_rollback_write
+              end
+
+              if @next_time < time
+                @output.try_flush
+                interval = @output.next_flush_time.to_f - Time.now.to_f
+                @next_time = Process.clock_gettime(clock_id) + interval
+              end
+
+              sleep interval
+            end
+          rescue => e
+            # normal errors are rescued by output plugins in #try_flush
+            # so this rescue section is for critical & unrecoverable errors
+            @log.error "error on output thread", error_class: e.class.to_s, error: e.to_s
+            @log.error_backtrace
+            raise
+          end
+        end
+      end
+    end
+  end
+end
diff --git a/lib/fluent/plugin/exec_util.rb b/lib/fluent/plugin/exec_util.rb
index 9ed3d9edff..fdc39a83e5 100644
--- a/lib/fluent/plugin/exec_util.rb
+++ b/lib/fluent/plugin/exec_util.rb
@@ -15,6 +15,8 @@
 #
 
 module Fluent
+  # Obsolete in v0.14
+  #  Use ChildProcess of PluginSupport and Parser instead
   module ExecUtil
     require 'fluent/parser'
 
@@ -83,6 +85,7 @@ def call(io)
         begin
           @u.each(&@on_message)
         rescue EOFError
+          # ignore
         end
       end
     end
@@ -119,4 +122,8 @@ def call(record, out)
       end
     end
   end
+
+  module Plugin
+    ExecUtil = Fluent::ExecUtil
+  end
 end
diff --git a/lib/fluent/plugin/in_debug_agent.rb b/lib/fluent/plugin/in_debug_agent.rb
index 17c87c0e56..b7fdcce891 100644
--- a/lib/fluent/plugin/in_debug_agent.rb
+++ b/lib/fluent/plugin/in_debug_agent.rb
@@ -14,6 +14,8 @@
 #    limitations under the License.
 #
 
+require 'fluent/input'
+
 module Fluent
   class DebugAgentInput < Input
     Plugin.register_input('debug_agent', self)
diff --git a/lib/fluent/plugin/in_dummy.rb b/lib/fluent/plugin/in_dummy.rb
index 00492ce006..374ebdb3ed 100644
--- a/lib/fluent/plugin/in_dummy.rb
+++ b/lib/fluent/plugin/in_dummy.rb
@@ -14,8 +14,15 @@
 #    limitations under the License.
 #
 
-module Fluent
-  class DummyInput < Input
+require 'fluent/plugin/input'
+require 'fluent/plugin_support/thread'
+require 'fluent/plugin_support/storage'
+
+module Fluent::Plugin
+  class DummyInput < Fluent::Plugin::Input
+    include Fluent::PluginSupport::Thread
+    include Fluent::PluginSupport::Storage
+
     Fluent::Plugin.register_input('dummy', self)
 
     BIN_NUM = 10
@@ -23,11 +30,13 @@ class DummyInput < Input
     desc "The value is the tag assigned to the generated events."
     config_param :tag, :string
     desc "It configures how many events to generate per second."
-    config_param :rate, :integer, :default => 1
+    config_param :rate, :integer, default: 1
     desc "If specified, each generated event has an auto-incremented key field."
-    config_param :auto_increment_key, :string, :default => nil
+    config_param :auto_increment_key, :string, default: nil
+    desc "The boolean to suspend-and-resume incremental value after restart"
+    config_param :suspend, :bool, default: false
     desc "The dummy data to be generated. An array of JSON hashes or a single JSON hash."
-    config_param :dummy, :default => [{"message"=>"dummy"}] do |val|
+    config_param :dummy, default: [{"message"=>"dummy"}] do |val|
       begin
         parsed = JSON.parse(val)
       rescue JSON::ParserError => e
@@ -46,34 +55,33 @@ class DummyInput < Input
     def configure(conf)
       super
 
-      @increment_value = 0
-      @dummy_index = 0
+      unless @suspend
+        storage.autosave = false
+        storage.save_at_shutdown = false
+      end
     end
 
     def start
       super
-      @running = true
-      @thread = Thread.new(&method(:run))
-    end
 
-    def shutdown
-      @running = false
-      @thread.join
-    end
+      storage.put(:increment_value, 0) unless storage.get(:increment_value)
+      storage.put(:dummy_index, 0) unless storage.get(:dummy_index)
 
-    def run
       batch_num    = (@rate / BIN_NUM).to_i
       residual_num = (@rate % BIN_NUM)
-      while @running
-        current_time = Time.now.to_i
-        BIN_NUM.times do
-          break unless (@running && Time.now.to_i <= current_time)
-          wait(0.1) { emit(batch_num) }
-        end
-        emit(residual_num)
-        # wait for next second
-        while @running && Time.now.to_i <= current_time
-          sleep 0.01
+
+      thread_create do
+        while thread_current_running?
+          current_time = Time.now.to_i
+          BIN_NUM.times do
+            break unless (thread_current_running? && Time.now.to_i <= current_time)
+            wait(0.1) { emit(batch_num) }
+          end
+          emit(residual_num)
+          # wait for next second
+          while thread_current_running? && Time.now.to_i <= current_time
+            sleep 0.01
+          end
         end
       end
     end
@@ -83,18 +91,24 @@ def emit(num)
     end
 
     def generate
-      d = @dummy[@dummy_index]
-      unless d
-        @dummy_index = 0
-        d = @dummy[0]
-      end
-      @dummy_index += 1
-      if @auto_increment_key
-        d = d.dup
-        d[@auto_increment_key] = @increment_value
-        @increment_value += 1
+      storage.synchronize do
+        index = storage.get(:dummy_index)
+        d = @dummy[index]
+        unless d
+          index = 0
+          d = @dummy[index]
+        end
+        storage.put(:dummy_index, index + 1)
+
+        if @auto_increment_key
+          d = d.dup
+          inc_value = storage.get(:increment_value)
+          d[@auto_increment_key] = inc_value
+          storage.put(:increment_value, inc_value + 1)
+        end
+
+        d
       end
-      d
     end
 
     def wait(time)
diff --git a/lib/fluent/plugin/in_exec.rb b/lib/fluent/plugin/in_exec.rb
index 57d6af097e..b902cbfeb2 100644
--- a/lib/fluent/plugin/in_exec.rb
+++ b/lib/fluent/plugin/in_exec.rb
@@ -14,9 +14,14 @@
 #    limitations under the License.
 #
 
-module Fluent
-  class ExecInput < Input
-    Plugin.register_input('exec', self)
+require 'fluent/plugin/input'
+require 'fluent/plugin_support/child_process'
+
+module Fluent::Plugin
+  class ExecInput < Fluent::Plugin::Input
+    include Fluent::PluginSupport::ChildProcess
+
+    Fluent::Plugin.register_input('exec', self)
 
     def initialize
       super
@@ -27,21 +32,23 @@ def initialize
     desc 'The command (program) to execute.'
     config_param :command, :string
     desc 'The format used to map the program output to the incoming event.(tsv,json,msgpack)'
-    config_param :format, :string, :default => 'tsv'
+    config_param :format, default: 'tsv'
     desc 'Specify the comma-separated keys when using the tsv format.'
-    config_param :keys, :default => [] do |val|
+    config_param :keys, default: [] do |val|
       val.split(',')
     end
     desc 'Tag of the output events.'
-    config_param :tag, :string, :default => nil
+    config_param :tag, :string, default: nil
     desc 'The key to use as the event tag instead of the value in the event record. '
-    config_param :tag_key, :string, :default => nil
+    config_param :tag_key, :string, default: nil
     desc 'The key to use as the event time instead of the value in the event record.'
-    config_param :time_key, :string, :default => nil
+    config_param :time_key, :string, default: nil
     desc 'The format of the event time used for the time_key parameter.'
-    config_param :time_format, :string, :default => nil
+    config_param :time_format, :string, default: nil
     desc 'The interval time between periodic program runs.'
-    config_param :run_interval, :time, :default => nil
+    config_param :run_interval, :time, default: nil
+    desc 'The flag to execute command immediately after startup'
+    config_param :run_immediately, :bool, default: false
 
     def configure(conf)
       super
@@ -96,56 +103,15 @@ def setup_parser(conf)
     end
 
     def start
-      if @run_interval
-        @finished = false
-        @thread = Thread.new(&method(:run_periodic))
-      else
-        @io = IO.popen(@command, "r")
-        @pid = @io.pid
-        @thread = Thread.new(&method(:run))
-      end
-    end
-
-    def shutdown
-      if @run_interval
-        @finished = true
-        # call Thread#run which interupts sleep in order to stop run_periodic thread immediately.
-        @thread.run
-        @thread.join
-      else
-        begin
-          Process.kill(:TERM, @pid)
-        rescue #Errno::ECHILD, Errno::ESRCH, Errno::EPERM
-        end
-        if @thread.join(60)  # TODO wait time
-          return
-        end
+      super
 
-        begin
-          Process.kill(:KILL, @pid)
-        rescue #Errno::ECHILD, Errno::ESRCH, Errno::EPERM
-        end
-        @thread.join
+      child_process_execute(command: @command, read: true, write: false, interval: @run_interval, immediate: @run_immediately) do |io|
+        @parser.call(io)
       end
     end
 
-    def run
-      @parser.call(@io)
-    end
-
-    def run_periodic
-      sleep @run_interval
-      until @finished
-        begin
-          io = IO.popen(@command, "r")
-          @parser.call(io)
-          Process.waitpid(io.pid)
-          sleep @run_interval
-        rescue
-          log.error "exec failed to run or shutdown child process", :error => $!.to_s, :error_class => $!.class.to_s
-          log.warn_backtrace $!.backtrace
-        end
-      end
+    def shutdown
+      super
     end
 
     private
@@ -169,7 +135,7 @@ def on_message(record, parsed_time = nil)
 
       router.emit(tag, time, record)
     rescue => e
-      log.error "exec failed to emit", :error => e.to_s, :error_class => e.class.to_s, :tag => tag, :record => Yajl.dump(record)
+      log.error "exec failed to emit", error: e.to_s, error_class: e.class.to_s, tag: tag, record: Yajl.dump(record)
     end
   end
 end
diff --git a/lib/fluent/plugin/in_forward.rb b/lib/fluent/plugin/in_forward.rb
index 05dfbd71a3..6544fb6119 100644
--- a/lib/fluent/plugin/in_forward.rb
+++ b/lib/fluent/plugin/in_forward.rb
@@ -14,94 +14,345 @@
 #    limitations under the License.
 #
 
-module Fluent
-  class ForwardInput < Input
-    Plugin.register_input('forward', self)
+require 'fluent/plugin/input'
+require 'fluent/plugin_support/tcp_server'
+require 'fluent/plugin_support/udp_server'
+require 'fluent/plugin_support/ssl_server'
 
-    def initialize
-      super
-      require 'fluent/plugin/socket_util'
-    end
+require 'openssl'
+require 'socket'
+
+module Fluent::Plugin
+  class ForwardInput < Fluent::Plugin::Input
+    DEFAULT_FORWARD_PORT = 24224
+
+    include Fluent::PluginSupport::TCPServer
+    include Fluent::PluginSupport::UDPServer
+    include Fluent::PluginSupport::SSLServer
+
+    Fluent::Plugin.register_input('forward', self)
+
+    # TODO: burst transferring mode
+
+    config_param :self_hostname, :string, default: Socket.gethostname
 
     desc 'The port to listen to.'
-    config_param :port, :integer, :default => DEFAULT_LISTEN_PORT
+    config_param :port, :integer, default: DEFAULT_FORWARD_PORT
     desc 'The bind address to listen to.'
-    config_param :bind, :string, :default => '0.0.0.0'
-    config_param :backlog, :integer, :default => nil
-    # SO_LINGER 0 to send RST rather than FIN to avoid lots of connections sitting in TIME_WAIT at src
-    desc 'The timeout time used to set linger option.'
-    config_param :linger_timeout, :integer, :default => 0
-    # This option is for Cool.io's loop wait timeout to avoid loop stuck at shutdown. Almost users don't need to change this value.
-    config_param :blocking_timeout, :time, :default => 0.5
+    config_param :bind, :string, default: '0.0.0.0'
+
+    config_param :keepalive, :integer, default: nil # [1-] seconds, 0/nil: don't allowed, -1: not to timeout
+
+    config_param :disable_udp_heartbeat, :bool, default: false
 
     desc 'Log warning if received chunk size is larger than this value.'
-    config_param :chunk_size_warn_limit, :size, :default => nil
+    config_param :chunk_size_warn_limit, :size, default: nil
     desc 'Received chunk is dropped if it is larger than this value.'
-    config_param :chunk_size_limit, :size, :default => nil
+    config_param :chunk_size_limit, :size, default: nil
     desc 'Skip an event if incoming event is invalid.'
-    config_param :skip_invalid_event, :bool, :default => false
+    config_param :skip_invalid_event, :bool, default: false
+
+    config_section :ssl, param_name: :ssl_options, required: false, multi: false do
+      config_param :version, default: :TLSv1_2 do |val|
+        ver = val.sub('.', '_').to_sym
+        unless OpenSSL::SSL::SSLContext::METHODS.include?(ver)
+          raise Fluent::ConfigError, "Invalid SSL version in this environment:'#{val}'"
+        end
+        ver
+      end
+      config_param :ciphers, :string, default: nil
+
+      # cert auto generation
+      config_param :digest, default: OpenSSL::Digest::SHA256 do |val|
+        begin
+          eval("OpenSSL::Digest::#{val}")
+        rescue NameError => e
+          raise Fluent::ConfigError, "Invalid digest method name in this environment:'#{val}'"
+        end
+      end
+      config_param :algorithm, default: OpenSSL::PKey::RSA do |val|
+        begin
+          eval("OpenSSL::PKey::#{val}")
+        rescue NameError => e
+          raise Fluent::ConfigError, "Invalid name for public key encryption in this environment:'#{val}'"
+        end
+      end
+      config_param :key_length, :integer, default: 2048
+      config_param :cert_country, :string, default: 'US'
+      config_param :cert_state, :string, default: 'CA'
+      config_param :cert_locality, :string, default: 'Mountain View'
+      config_param :cert_common_name, :string, default: 'Fluentd forward plugin'
+
+      # cert file
+      config_param :cert_path, :string, default: nil
+      config_param :key_path, :string, default: nil
+      config_param :key_passphrase, :string, default: nil # you can use ENV w/ in-place ruby code
+
+      # CA cert to generate server certs
+      config_param :ca_cert_path, :string, default: nil
+      config_param :ca_key_path, :string, default: nil
+      config_param :ca_key_passphrase, :string, default: nil # you can use ENV w/ in-place ruby code
+    end
+
+    # TODO check recent fluent-plugin-secure-forward updates
+    config_section :security, required: false, multi: false do
+      config_param :shared_key, :string
+      config_param :user_auth, :bool, default: false
+      config_param :allow_anonymous_source, :bool, default: true
+
+      ### User based authentication
+      config_section :user, param_name: :users, required: false, multi: true do
+        config_param :username, :string
+        config_param :password, :string
+      end
+
+      ### Client ip/network authentication & per_host shared key
+      config_section :client, param_name: :clients, required: false, multi: true do
+        config_param :host, :string, default: nil
+        config_param :network, :string, default: nil
+        config_param :shared_key, :string, default: nil
+        config_param :users, :array, default: []
+      end
+    end
+
+    # SO_LINGER 0 to send RST rather than FIN to avoid lots of connections sitting in TIME_WAIT at src
+    # TODO: lingr/backlog in *_server?
+    desc 'The timeout time used to set linger option.'
+    config_param :linger_timeout, :integer, default: 0
+    config_param :backlog, :integer, default: nil
 
     def configure(conf)
       super
+
+      if @ssl_options
+        unless @ssl_options.cert_auto_generate
+          opts = @ssl_options
+          unless opts.cert_file && opts.key_file && opts.key_passphrase
+            raise Fluent::ConfigError, "cert_file, key_file and key_passphrase are needed"
+          end
+        end
+      end
+
+      if @security
+        if @security.user_auth && @security.users.empty?
+          raise Fluent::ConfigError, "<user> sections required if user_auth enabled"
+        end
+        if !@security.allow_anonymous_source && @security.clients.empty?
+          raise Fluent::ConfigError, "<client> sections required if allow_anonymous_source disabled"
+        end
+
+        @cert, @key = prepare_cert_key_pair(@ssl_options)
+
+        @security.clients.each do |client|
+          if client.host && client.network
+            raise Fluent::ConfigError, "both of 'host' and 'network' are specified for client"
+          end
+          if !client.host && !client.network
+            raise Fluent::ConfigError, "Either of 'host' and 'network' must be specified for client"
+          end
+          source = nil
+          if client.host
+            begin
+              source = IPSocket.getaddress(client.host)
+            rescue SocketError => e
+              raise Fluent::ConfigError, "host '#{client.host}' cannot be resolved"
+            end
+          end
+          source_addr = begin
+                          IPAddr.new(source || client.network)
+                        rescue ArgumentError => e
+                          raise Fluent::ConfigError, "network '#{client.network}' address format is invalid"
+                        end
+          @nodes = []
+          @nodes.push({
+              address: source_addr,
+              shared_key: (client.shared_key || @security.shared_key),
+              users: client.users
+            })
+        end
+      end
     end
 
     def start
-      @loop = Coolio::Loop.new
-
-      @lsock = listen
-      @loop.attach(@lsock)
+      super
 
-      @usock = SocketUtil.create_udp_socket(@bind)
-      @usock.bind(@bind, @port)
-      @usock.fcntl(Fcntl::F_SETFL, Fcntl::O_NONBLOCK)
-      @hbr = HeartbeatRequestHandler.new(@usock, method(:on_heartbeat_request))
-      @loop.attach(@hbr)
+      server_keepalive = if @keepalive && @keepalive == -1
+                           nil # infinity
+                         elsif @keepalive.nil? || @keepalive == 0
+                           @keepalive = nil
+                           1 # don't do keepalive, but wait 1 second to read at least
+                         else
+                           @keepalive
+                         end
+
+      if @ssl_options # TCP+SSL
+        version = @ssl_options.version
+        ssl_server_listen(ssl_version: version, ciphers: @ssl_options.ciphers, cert: @cert, key: @key, port: @port, bind: @bind, keepalive: server_keepalive, linger_timeout: @linger_timeout, backlog: @backlog, &method(:handle_connection))
+      else # TCP
+        tcp_server_listen(port: @port, bind: @bind, keepalive: server_keepalive, linger_timeout: @linger_timeout, backlog: @backlog, &method(:handle_connection))
+      end
 
-      @thread = Thread.new(&method(:run))
+      unless @disable_udp_heartbeat
+        # UDP heartbeat
+        udp_server_listen(port: @port, bind: @bind) do |sock|
+          sock.read(size_limit: 1024) do |remote_addr, remote_port, data|
+            begin
+              sock.send(host: remote_addr, port: remote_port, data: "\0")
+            rescue Errno::EAGAIN, Errno::EWOULDBLOCK, Errno::EINTR
+              # ignore errors
+              # TODO debug log?
+            end
+          end
+        end
+      end
     end
 
     def shutdown
-      # In test cases it occasionally appeared that when detaching a watcher, another watcher is also detached.
-      # In the case in the iteration of watchers, a watcher that has been already detached is intended to be detached
-      # and therfore RuntimeError occurs saying that it is not attached to a loop.
-      # It occures only when testing for sending responses to ForwardOutput.
-      # Sending responses needs to write the socket that is previously used only to read
-      # and a handler has 2 watchers that is used to read and to write.
-      # This problem occurs possibly because those watchers are thought to be related to each other
-      # and when detaching one of them the other is also detached for some reasons.
-      # As a workaround, check if watchers are attached before detaching them.
-      @loop.watchers.each {|w| w.detach if w.attached? }
-      @loop.stop
-      @usock.close
-      @thread.join
-      @lsock.close
+      super
+      # nothing to do (maybe)
+    end
+
+    def prepare_cert_key_pair(opts)
+      if opts.cert_path
+        return ssl_server_load_cert_key(
+          cert_file_path: opts.cert_path,
+          algorithm: opts.algorithm,
+          key_file_path: opts.key_path,
+          key_passphrase: opts.key_passphrase,
+        )
+      elsif opts.ca_cert_path
+        ca_cert, ca_key = ssl_server_load_cert_key(
+          cert_file_path: opts.ca_cert_path,
+          algorithm: opts.algorithm,
+          key_file_path: opts.ca_key_path,
+          key_passphrase: opts.ca_key_passphrase,
+        )
+        return ssl_server_generate_cert_key(
+          digest: opts.digest,
+          algorithm: opts.algorithm,
+          key_length: opts.key_length,
+          cert_country: opts.cert_country,
+          cert_state: opts.cert_state,
+          cert_locality: opts.cert_locality,
+          cert_common_name: opts.cert_common_name,
+          ca_cert: ca_cert,
+          ca_key: ca_key,
+        )
+      else
+        return ssl_server_generate_cert_key(
+          digest: opts.digest,
+          algorithm: opts.algorithm,
+          key_length: opts.key_length,
+          cert_country: opts.cert_country,
+          cert_state: opts.cert_state,
+          cert_locality: opts.cert_locality,
+          cert_common_name: opts.cert_common_name,
+        )
+      end
     end
 
-    def listen
-      log.info "listening fluent socket on #{@bind}:#{@port}"
-      s = Coolio::TCPServer.new(@bind, @port, Handler, @linger_timeout, log, method(:on_message))
-      s.listen(@backlog) unless @backlog.nil?
-      s
+    def handle_connection(conn)
+      send_data = ->(serializer, data){ conn.write serializer.call(data) }
+
+      # TODO: trace logging to be connected this host!
+      state = :established
+      nonce = nil
+      user_auth_salt = nil
+
+      if @security
+        # security enabled session MUST use MessagePack as serialization format
+        state = :helo
+        nonce = generate_salt
+        user_auth_salt = generate_salt
+        send_data.call( :to_msgpack.to_proc, generate_helo(nonce, user_auth_salt) )
+        state = :pingpong
+      end
+
+      # TODO: trace logging to be connected this host!
+      #    if io.is_a?(TCPSocket)
+      #      PEERADDR_FAILED = ["?", "?", "name resolusion failed", "?"]
+      #      proto, port, host, addr = ( io.peeraddr rescue PEERADDR_FAILED )
+      #      @source = "host: #{host}, addr: #{addr}, port: #{port}"
+      #    end
+      #   @log = log
+      #   @log.trace {
+      #     begin
+      #       remote_port, remote_addr = *Socket.unpack_sockaddr_in(@_io.getpeername)
+      #     rescue => e
+      #       remote_port = nil
+      #       remote_addr = nil
+      #     end
+      #     "accepted fluent socket from '#{remote_addr}:#{remote_port}': object_id=#{self.object_id}"
+      #   }
+
+      read_messages(conn) do |msg, chunk_size, serializer|
+        case state
+        when :pingpong
+          success, reason_or_salt, shared_key = self.check_ping(msg, conn.remote_addr, user_auth_salt, nonce)
+          if not success
+            send_data.call( serializer, generate_pong(false, reason_or_salt, nonce, shared_key) )
+            conn.close
+            next
+          end
+          send_data.call( serializer, generate_pong(true, reason_or_salt, nonce, shared_key) )
+
+          # TODO: log.debug "connection established"
+          state = :established
+        when :established
+          options = emit_message(msg, chunk_size, conn.remote_addr)
+          if options && r = response(options)
+            send_data.call( serializer, r )
+            # TODO: logging message content
+            # log.trace "sent response to fluent socket"
+          end
+          unless @keepalive
+            conn.close
+          end
+        else
+          raise "BUG: unknown session state: #{state}"
+        end
+      end
     end
 
-    #config_param :path, :string, :default => DEFAULT_SOCKET_PATH
-    #def listen
-    #  if File.exist?(@path)
-    #    File.unlink(@path)
-    #  end
-    #  FileUtils.mkdir_p File.dirname(@path)
-    #  log.debug "listening fluent socket on #{@path}"
-    #  Coolio::UNIXServer.new(@path, Handler, method(:on_message))
-    #end
-
-    def run
-      @loop.run(@blocking_timeout)
-    rescue => e
-      log.error "unexpected error", :error => e, :error_class => e.class
-      log.error_backtrace
+    def read_messages(conn, &block)
+      feeder = nil
+      serializer = nil
+      bytes = 0
+      conn.on_data do |data|
+        # only for first call of callback
+        unless feeder
+          first = data[0]
+          if first == '{' || first == '[' # json
+            parser = Yajl::Parser.new
+            parser.on_parse_complete = ->(obj){
+              block.call(obj, bytes, serializer)
+              bytes = 0
+            }
+            serializer = :to_json.to_proc
+            feeder = ->(d){ parser << d }
+          else # msgpack
+            parser = MessagePack::Unpacker.new
+            serializer = :to_msgpack.to_proc
+            feeder = ->(d){
+              parser.feed_each(d){|obj|
+                block.call(obj, bytes, serializer)
+                bytes = 0
+              }
+            }
+          end
+        end
+
+        bytes += data.bytesize
+        feeder.call(data)
+      end
     end
 
-    private
+    def response(option)
+      if option && option['chunk']
+        return { 'ack' => option['chunk'] }
+      end
+      nil
+    end
 
     # message Entry {
     #   1: long time
@@ -126,19 +377,20 @@ def run
     #   3: object record
     #   4: object option (optional)
     # }
-    def on_message(msg, chunk_size, source)
-      if msg.nil?
-        # for future TCP heartbeat_request
+
+    def emit_message(msg, chunk_size, source)
+      if msg.nil? # TCP heartbeat
         return
       end
 
       # TODO: raise an exception if broken chunk is generated by recoverable situation
       unless msg.is_a?(Array)
+        # TODO dumping whole msg make fluentd's log flooding. Fix it as `type: msg.class.name`
         log.warn "incoming chunk is broken:", source: source, msg: msg
         return
       end
 
-      tag = msg[0]
+      tag = msg[0] # TODO to_s ?
       entries = msg[1]
 
       if @chunk_size_limit && (chunk_size > @chunk_size_limit)
@@ -150,7 +402,7 @@ def on_message(msg, chunk_size, source)
 
       if entries.class == String
         # PackedForward
-        es = MessagePackEventStream.new(entries)
+        es = Fluent::MessagePackEventStream.new(entries)
         es = check_and_skip_invalid_event(tag, es, source) if @skip_invalid_event
         router.emit_stream(tag, es)
         option = msg[2]
@@ -160,7 +412,7 @@ def on_message(msg, chunk_size, source)
         es = if @skip_invalid_event
                check_and_skip_invalid_event(tag, entries, source)
              else
-               es = MultiEventStream.new
+               es = Fluent::MultiEventStream.new
                entries.each { |e|
                  record = e[1]
                  next if record.nil?
@@ -182,7 +434,7 @@ def on_message(msg, chunk_size, source)
           return msg[3] # retry never succeeded so return ack and drop incoming event.
         end
         return if record.nil?
-        time = Engine.now if time.to_i == 0
+        time = Fluent::Engine.now if time.to_i == 0 # to_i is for Fluent::EventTime
         router.emit(tag, time, record)
         option = msg[3]
       end
@@ -207,122 +459,98 @@ def check_and_skip_invalid_event(tag, es, source)
       new_es
     end
 
-    class Handler < Coolio::Socket
-      PEERADDR_FAILED = ["?", "?", "name resolusion failed", "?"]
-
-      def initialize(io, linger_timeout, log, on_message)
-        super(io)
-
-        if io.is_a?(TCPSocket) # for unix domain socket support in the future
-          proto, port, host, addr = ( io.peeraddr rescue PEERADDR_FAILED )
-          @source = "host: #{host}, addr: #{addr}, port: #{port}"
-
-          opt = [1, linger_timeout].pack('I!I!')  # { int l_onoff; int l_linger; }
-          io.setsockopt(Socket::SOL_SOCKET, Socket::SO_LINGER, opt)
-        end
-
-        @chunk_counter = 0
-        @on_message = on_message
-        @log = log
-        @log.trace {
-          begin
-            remote_port, remote_addr = *Socket.unpack_sockaddr_in(@_io.getpeername)
-          rescue => e
-            remote_port = nil
-            remote_addr = nil
-          end
-          "accepted fluent socket from '#{remote_addr}:#{remote_port}': object_id=#{self.object_id}"
-        }
+    def select_authenticate_users(node, username)
+      if node.nil? || node[:users].empty?
+        @security.users.select{|u| u.username == username}
+      else
+        @security.users.select{|u| node[:users].include?(u.username) && u.username == username}
       end
+    end
 
-      def on_connect
-      end
+    def generate_salt
+      OpenSSL::Random.random_bytes(16)
+    end
 
-      def on_read(data)
-        first = data[0]
-        if first == '{' || first == '['
-          m = method(:on_read_json)
-          @serializer = :to_json.to_proc
-          @y = Yajl::Parser.new
-          @y.on_parse_complete = lambda { |obj|
-            option = @on_message.call(obj, @chunk_counter, @source)
-            respond option if option
-            @chunk_counter = 0
-          }
-        else
-          m = method(:on_read_msgpack)
-          @serializer = :to_msgpack.to_proc
-          @u = Fluent::Engine.msgpack_factory.unpacker
-        end
+    def generate_helo(nonce, user_auth_salt)
+      log.debug "generating helo"
+      # ['HELO', options(hash)]
+      [ 'HELO', {'nonce' => nonce, 'auth' => (@security ? user_auth_salt : ''), 'keepalive' => @allow_keepalive } ]
+    end
 
-        (class << self; self; end).module_eval do
-          define_method(:on_read, m)
-        end
-        m.call(data)
+    def check_ping(message, remote_addr, user_auth_salt, nonce)
+      log.debug "checking ping"
+      # ['PING', self_hostname, shared_key_salt, sha512_hex(shared_key_salt + self_hostname + nonce + shared_key), username || '', sha512_hex(auth_salt + username + password) || '']
+      unless message.size == 6 && message[0] == 'PING'
+        return false, 'invalid ping message'
       end
+      ping, hostname, shared_key_salt, shared_key_hexdigest, username, password_digest = message
 
-      def on_read_json(data)
-        @chunk_counter += data.bytesize
-        @y << data
-      rescue => e
-        @log.error "forward error", :error => e, :error_class => e.class
-        @log.error_backtrace
-        close
+      node = @nodes.select{|n| n[:address].include?(remote_addr) rescue false }.first
+      if !node && !@security.allow_anonymous_source
+        log.warn "Anonymous client disallowed", address: remote_addr, hostname: hostname
+        return false, "anonymous source host '#{remote_addr}' denied", nil
       end
 
-      def on_read_msgpack(data)
-        @chunk_counter += data.bytesize
-        @u.feed_each(data) do |obj|
-          option = @on_message.call(obj, @chunk_counter, @source)
-          respond option if option
-          @chunk_counter = 0
-        end
-      rescue => e
-        @log.error "forward error", :error => e, :error_class => e.class
-        @log.error_backtrace
-        close
+      shared_key = node ? node[:shared_key] : @security.shared_key
+      serverside = Digest::SHA512.new.update(shared_key_salt).update(hostname).update(nonce).update(shared_key).hexdigest
+      if shared_key_hexdigest != serverside
+        log.warn "Shared key mismatch", address: remote_addr, hostname: hostname
+        return false, 'shared_key mismatch', nil
       end
 
-      def respond(option)
-        if option && option['chunk']
-          res = { 'ack' => option['chunk'] }
-          write @serializer.call(res)
-          @log.trace { "sent response to fluent socket" }
+      if @security.user_auth
+        users = select_authenticate_users(node, username)
+        success = false
+        users.each do |user|
+          passhash = Digest::SHA512.new.update(user_auth_salt).update(username).update(user[:password]).hexdigest
+          success ||= (passhash == password_digest)
+        end
+        unless success
+          log.warn "Authentication failed", address: remote_addr, hostname: hostname, username: username
+          return false, 'username/password mismatch', nil
         end
       end
 
-      def on_close
-        @log.trace { "closed socket" }
-      end
+      return true, shared_key_salt, node[:shared_key]
     end
 
-    class HeartbeatRequestHandler < Coolio::IO
-      def initialize(io, callback)
-        super(io)
-        @io = io
-        @callback = callback
-      end
-
-      def on_readable
-        begin
-          msg, addr = @io.recvfrom(1024)
-        rescue Errno::EAGAIN, Errno::EWOULDBLOCK, Errno::EINTR
-          return
-        end
-        host = addr[3]
-        port = addr[1]
-        @callback.call(host, port, msg)
-      rescue
-        # TODO log?
+    def generate_pong(auth_result, reason_or_salt, nonce, shared_key)
+      log.debug "generating pong"
+      # ['PONG', bool(authentication result), 'reason if authentication failed', self_hostname, sha512_hex(salt + self_hostname + nonce + sharedkey)]
+      unless auth_result
+        return ['PONG', false, reason_or_salt, '', '']
       end
-    end
 
-    def on_heartbeat_request(host, port, msg)
-      #log.trace "heartbeat request from #{host}:#{port}"
-      begin
-        @usock.send "\0", 0, host, port
-      rescue Errno::EAGAIN, Errno::EWOULDBLOCK, Errno::EINTR
-      end
+      shared_key_digest_hex = Digest::SHA512.new.update(reason_or_salt).update(@self_hostname).update(nonce).update(shared_key).hexdigest
+      [ 'PONG', true, '', @self_hostname, shared_key_digest_hex ]
     end
   end
 end
+
+##### Authentication Handshake
+#
+# 1. (client) connect to server
+#   * Socket handshake, checks certificate and its significate (in client, if using SSL)
+# 2. (server)
+#   * check network/domain acl (if enabled)
+#   * disconnect when failed
+# 3. (server) send HELO
+#   * ['HELO', options(hash)]
+#   * options:
+#     * nonce: string (required)
+#     * auth: string or blank_string (string: authentication required, and its salt is this value)
+#     * keepalive: bool (allowed or not)
+# 4. (client) send PING
+#   * ['PING', selfhostname, sharedkey_salt, sha512_hex(sharedkey_salt + selfhostname + nonce + sharedkey), username || '', sha512_hex(auth_salt + username + password) || '']
+# 5. (server) check PING
+#   * check sharedkey
+#   * check username / password (if required)
+#   * send PONG FAILURE if failed
+#   * ['PONG', false, 'reason of authentication failure', '', '']
+# 6. (server) send PONG
+#   * ['PONG', bool(authentication result), 'reason if authentication failed', selfhostname, sha512_hex(salt + selfhostname + nonce + sharedkey)]
+# 7. (client) check PONG
+#   * check sharedkey
+#   * disconnect when failed
+# 8. connection established
+#   * send data from client (until keepalive expiration)
diff --git a/lib/fluent/plugin/in_gc_stat.rb b/lib/fluent/plugin/in_gc_stat.rb
deleted file mode 100644
index e68297b138..0000000000
--- a/lib/fluent/plugin/in_gc_stat.rb
+++ /dev/null
@@ -1,74 +0,0 @@
-#
-# Fluentd
-#
-#    Licensed under the Apache License, Version 2.0 (the "License");
-#    you may not use this file except in compliance with the License.
-#    You may obtain a copy of the License at
-#
-#        http://www.apache.org/licenses/LICENSE-2.0
-#
-#    Unless required by applicable law or agreed to in writing, software
-#    distributed under the License is distributed on an "AS IS" BASIS,
-#    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-#    See the License for the specific language governing permissions and
-#    limitations under the License.
-#
-
-module Fluent
-  class GCStatInput < Input
-    Plugin.register_input('gc_stat', self)
-
-    def initialize
-      super
-    end
-
-    config_param :emit_interval, :time, :default => 60
-    config_param :tag, :string
-
-    class TimerWatcher < Coolio::TimerWatcher
-      def initialize(interval, repeat, log, &callback)
-        @callback = callback
-        @log = log
-        super(interval, repeat)
-      end
-
-      def on_timer
-        @callback.call
-      rescue
-        # TODO log?
-        @log.error $!.to_s
-        @log.error_backtrace
-      end
-    end
-
-    def configure(conf)
-      super
-    end
-
-    def start
-      @loop = Coolio::Loop.new
-      @timer = TimerWatcher.new(@emit_interval, true, log, &method(:on_timer))
-      @loop.attach(@timer)
-      @thread = Thread.new(&method(:run))
-    end
-
-    def shutdown
-      @loop.watchers.each {|w| w.detach }
-      @loop.stop
-      @thread.join
-    end
-
-    def run
-      @loop.run
-    rescue
-      log.error "unexpected error", :error=>$!.to_s
-      log.error_backtrace
-    end
-
-    def on_timer
-      now = Engine.now
-      record = GC.stat
-      router.emit(@tag, now, record)
-    end
-  end
-end
diff --git a/lib/fluent/plugin/in_http.rb b/lib/fluent/plugin/in_http.rb
index 7a29e2aab5..d2de566d5f 100644
--- a/lib/fluent/plugin/in_http.rb
+++ b/lib/fluent/plugin/in_http.rb
@@ -14,42 +14,54 @@
 #    limitations under the License.
 #
 
-module Fluent
-  class HttpInput < Input
-    Plugin.register_input('http', self)
+require 'fluent/plugin/input'
+require 'fluent/process'
+require 'fluent/plugin_support/tcp_server'
 
-    include DetachMultiProcessMixin
+require 'http/parser'
+require 'webrick/httputils'
+require 'uri'
 
-    require 'http/parser'
+module Fluent::Plugin
+  class HttpInput < Fluent::Plugin::Input
+    include Fluent::DetachMultiProcessMixin
+    include Fluent::PluginSupport::TCPServer
 
-    def initialize
-      require 'webrick/httputils'
-      require 'uri'
-      super
-    end
+    Fluent::Plugin.register_input('http', self)
 
     EMPTY_GIF_IMAGE = "GIF89a\u0001\u0000\u0001\u0000\x80\xFF\u0000\xFF\xFF\xFF\u0000\u0000\u0000,\u0000\u0000\u0000\u0000\u0001\u0000\u0001\u0000\u0000\u0002\u0002D\u0001\u0000;".force_encoding("UTF-8")
 
     desc 'The port to listen to.'
-    config_param :port, :integer, :default => 9880
+    config_param :port, :integer, default: 9880
+
     desc 'The bind address to listen to.'
-    config_param :bind, :string, :default => '0.0.0.0'
+    config_param :bind, :string, default: '0.0.0.0'
+
+    # request/response options
+    desc 'The format of the HTTP request content body, or "default" (query params).'
+    config_param :format, :string, default: 'default'
+
     desc 'The size limit of the POSTed element. Default is 32MB.'
-    config_param :body_size_limit, :size, :default => 32*1024*1024  # TODO default
-    desc 'The timeout limit for keeping the connection alive.'
-    config_param :keepalive_timeout, :time, :default => 10   # TODO default
-    config_param :backlog, :integer, :default => nil
-    desc 'Add HTTP_ prefix headers to the record.'
-    config_param :add_http_headers, :bool, :default => false
-    desc 'Add REMOTE_ADDR header to the record.'
-    config_param :add_remote_addr, :bool, :default => false
-    desc 'The format of the HTTP body.'
-    config_param :format, :string, :default => 'default'
-    config_param :blocking_timeout, :time, :default => 0.5
+    config_param :body_size_limit, :size, default: 32*1024*1024  # 32MB
+
     desc 'Set a white list of domains that can do CORS (Cross-Origin Resource Sharing)'
-    config_param :cors_allow_origins, :array, :default => nil
+    config_param :cors_allow_origins, :array, default: nil
+
     desc 'Respond with empty gif image of 1x1 pixel.'
-    config_param :respond_with_empty_img, :bool, :default => false
+    config_param :respond_with_empty_img, :bool, default: false
+
+    # emit data options
+    desc 'Add HTTP_ prefix headers to the record.'
+    config_param :add_http_headers, :bool, default: false
+
+    desc 'Add REMOTE_ADDR header to the record.'
+    config_param :add_remote_addr, :bool, default: false
+
+    # server options
+    desc 'The timeout limit for keeping the connection alive.'
+    config_param :keepalive_timeout, :time, default: 10
+
+    config_param :backlog, :integer, default: nil
 
     def configure(conf)
       super
@@ -57,7 +69,7 @@ def configure(conf)
       m = if @format == 'default'
             method(:parse_params_default)
           else
-            @parser = Plugin.new_parser(@format)
+            @parser = Fluent::Plugin.new_parser(@format)
             @parser.configure(conf)
             method(:parse_params_with_parser)
           end
@@ -66,63 +78,30 @@ def configure(conf)
       end
     end
 
-    class KeepaliveManager < Coolio::TimerWatcher
-      def initialize(timeout)
-        super(1, true)
-        @cons = {}
-        @timeout = timeout.to_i
-      end
-
-      def add(sock)
-        @cons[sock] = sock
-      end
-
-      def delete(sock)
-        @cons.delete(sock)
-      end
-
-      def on_timer
-        @cons.each_pair {|sock,val|
-          if sock.step_idle > @timeout
-            sock.close
-          end
-        }
-      end
-    end
-
     def start
+      super
+
       log.debug "listening http on #{@bind}:#{@port}"
-      lsock = TCPServer.new(@bind, @port)
-
-      detach_multi_process do
-        super
-        @km = KeepaliveManager.new(@keepalive_timeout)
-        #@lsock = Coolio::TCPServer.new(@bind, @port, Handler, @km, method(:on_request), @body_size_limit)
-        @lsock = Coolio::TCPServer.new(lsock, nil, Handler, @km, method(:on_request),
-                                       @body_size_limit, @format, log,
-                                       @cors_allow_origins)
-        @lsock.listen(@backlog) unless @backlog.nil?
-
-        @loop = Coolio::Loop.new
-        @loop.attach(@km)
-        @loop.attach(@lsock)
-
-        @thread = Thread.new(&method(:run))
+
+      tcp_server_listen(port: @port, bind: @bind, keepalive: @keepalive_timeout, backlog: @backlog) do |conn_handler|
+        http_parser_handler = HttpParserHandler.new(
+          io_handler: conn_handler,
+          callback: method(:on_request),
+          format: format,
+          body_size_limit: @body_size_limit,
+          cors_allow_origins: @cors_allow_origins
+        )
+        http_parser = Http::Parser.new(http_parser_handler)
+        http_parser_handler.http_parser = http_parser
+
+        conn_handler.on_data do |data|
+          http_parser << data
+        end
       end
     end
 
     def shutdown
-      @loop.watchers.each {|w| w.detach }
-      @loop.stop
-      @lsock.close
-      @thread.join
-    end
-
-    def run
-      @loop.run(@blocking_timeout)
-    rescue
-      log.error "unexpected error", :error=>$!.to_s
-      log.error_backtrace
+      super
     end
 
     def on_request(path_info, params)
@@ -154,11 +133,12 @@ def on_request(path_info, params)
         end
         time = if param_time = params['time']
                  param_time = param_time.to_f
-                 param_time.zero? ? Engine.now : Fluent::EventTime.from_time(Time.at(param_time))
+                 param_time.zero? ? Fluent::Engine.now : Fluent::EventTime.from_time(Time.at(param_time))
                else
-                 record_time.nil? ? Engine.now : record_time
+                 record_time.nil? ? Fluent::Engine.now : record_time
                end
-      rescue
+      rescue => e
+        # TODO: debug/trace logging
         return ["400 Bad Request", {'Content-type'=>'text/plain'}, "400 Bad Request\n#{$!}\n"]
       end
 
@@ -166,7 +146,7 @@ def on_request(path_info, params)
       begin
         # Support batched requests
         if record.is_a?(Array)
-          mes = MultiEventStream.new
+          mes = Fluent::MultiEventStream.new
           record.each do |single_record|
             if @add_http_headers
               params.each_pair { |k,v|
@@ -204,7 +184,7 @@ def parse_params_default(params)
                elsif js = params['json']
                  JSON.parse(js)
                else
-                 raise "'json' or 'msgpack' parameter is required"
+                 raise "'json' or 'msgpack' parameter is required for 'default' format"
                end
       return nil, record
     end
@@ -213,68 +193,51 @@ def parse_params_default(params)
 
     def parse_params_with_parser(params)
       if content = params[EVENT_RECORD_PARAMETER]
-        @parser.parse(content) { |time, record|
+        @parser.parse(content) do |time, record|
           raise "Received event is not #{@format}: #{content}" if record.nil?
           return time, record
-        }
+        end
       else
         raise "'#{EVENT_RECORD_PARAMETER}' parameter is required"
       end
     end
 
-    class Handler < Coolio::Socket
-      def initialize(io, km, callback, body_size_limit, format, log, cors_allow_origins)
-        super(io)
-        @km = km
+    class HttpParserHandler
+      attr_accessor :http_parser
+      attr_reader :content_type, :origin
+
+      def initialize(io_handler: nil, callback: ->(path_infor, params){}, body_size_limit: nil, format: 'default', cors_allow_origins: nil)
+        @io_handler = io_handler
+        @http_parser = nil # to be set after instanciation
+
         @callback = callback
+
         @body_size_limit = body_size_limit
-        @next_close = false
         @format = format
-        @log = log
         @cors_allow_origins = cors_allow_origins
-        @idle = 0
-        @km.add(self)
-
-        @remote_port, @remote_addr = *Socket.unpack_sockaddr_in(io.getpeername) rescue nil
-      end
-
-      def step_idle
-        @idle += 1
-      end
 
-      def on_close
-        @km.delete(self)
-      end
-
-      def on_connect
-        @parser = Http::Parser.new(self)
-      end
-
-      def on_read(data)
-        @idle = 0
-        @parser << data
-      rescue
-        @log.warn "unexpected error", :error=>$!.to_s
-        @log.warn_backtrace
-        close
+        @closing = false
       end
 
       def on_message_begin
         @body = ''
+        @env = {}
+        @content_type = ''
+        @origin = nil
+
+        @closing = false
       end
 
       def on_headers_complete(headers)
         expect = nil
         size = nil
 
-        if @parser.http_version == [1, 1]
+        if @http_parser.http_version == [1, 1] # TODO: HTTP/2.0
           @keep_alive = true
         else
           @keep_alive = false
         end
-        @env = {}
-        @content_type = ""
-        headers.each_pair {|k,v|
+        headers.each_pair do |k,v|
           @env["HTTP_#{k.gsub('-','_').upcase}"] = v
           case k
           when /Expect/i
@@ -292,24 +255,24 @@ def on_headers_complete(headers)
           when /Origin/i
             @origin  = v
           end
-        }
+        end
         if expect
           if expect == '100-continue'
             if !size || size < @body_size_limit
-              send_response_nobody("100 Continue", {})
+              send_response("100 Continue", {}, nil)
             else
-              send_response_and_close("413 Request Entity Too Large", {}, "Too large")
+              send_response("413 Request Entity Too Large", {}, "Too large")
             end
           else
-            send_response_and_close("417 Expectation Failed", {}, "")
+            send_response("417 Expectation Failed", {}, "")
           end
         end
       end
 
       def on_body(chunk)
         if @body.bytesize + chunk.bytesize > @body_size_limit
-          unless closing?
-            send_response_and_close("413 Request Entity Too Large", {}, "Too large")
+          unless @closing
+            send_response("413 Request Entity Too Large", {}, "Too large")
           end
           return
         end
@@ -317,7 +280,7 @@ def on_body(chunk)
       end
 
       def on_message_complete
-        return if closing?
+        return if @closing
 
         # CORS check
         # ==========
@@ -325,14 +288,14 @@ def on_message_complete
         # restrictions and white listed origins through @cors_allow_origins.
         unless @cors_allow_origins.nil?
           unless @cors_allow_origins.include?(@origin)
-            send_response_and_close("403 Forbidden", {'Connection' => 'close'}, "")
+            send_response("403 Forbidden", {'Connection' => 'close'}, "")
             return
           end
         end
 
-        @env['REMOTE_ADDR'] = @remote_addr if @remote_addr
+        @env['REMOTE_ADDR'] = @io_handler.remote_addr if @io_handler.remote_addr
 
-        uri = URI.parse(@parser.request_url)
+        uri = URI.parse(@http_parser.request_url)
         params = WEBrick::HTTPUtils.parse_query(uri.query)
 
         if @format != 'default'
@@ -355,46 +318,30 @@ def on_message_complete
 
         if @keep_alive
           header['Connection'] = 'Keep-Alive'
-          send_response(code, header, body)
-        else
-          send_response_and_close(code, header, body)
         end
-      end
-
-      def on_write_complete
-        close if @next_close
-      end
-
-      def send_response_and_close(code, header, body)
         send_response(code, header, body)
-        @next_close = true
       end
 
-      def closing?
-        @next_close
-      end
+      def send_response(code, header, body=nil)
+        unless @keep_alive
+          @io_handler.closing = true # keepalive disabled for HTTP/1.0 (or earlier)
+        end
 
-      def send_response(code, header, body)
-        header['Content-length'] ||= body.bytesize
-        header['Content-type'] ||= 'text/plain'
+        if body
+          header['Content-length'] ||= body.bytesize
+          header['Content-type'] ||= 'text/plain'
+        end
 
         data = %[HTTP/1.1 #{code}\r\n]
-        header.each_pair {|k,v|
+        header.each_pair do |k,v|
           data << "#{k}: #{v}\r\n"
-        }
+        end
         data << "\r\n"
-        write data
-
-        write body
-      end
+        @io_handler.write data
 
-      def send_response_nobody(code, header)
-        data = %[HTTP/1.1 #{code}\r\n]
-        header.each_pair {|k,v|
-          data << "#{k}: #{v}\r\n"
-        }
-        data << "\r\n"
-        write data
+        if body
+          @io_handler.write body
+        end
       end
     end
   end
diff --git a/lib/fluent/plugin/in_syslog.rb b/lib/fluent/plugin/in_syslog.rb
index 0ec6148562..6848dbee09 100644
--- a/lib/fluent/plugin/in_syslog.rb
+++ b/lib/fluent/plugin/in_syslog.rb
@@ -14,9 +14,19 @@
 #    limitations under the License.
 #
 
-module Fluent
-  class SyslogInput < Input
-    Plugin.register_input('syslog', self)
+require 'fluent/plugin/input'
+require 'fluent/parser'
+require 'fluent/plugin_support/tcp_server'
+require 'fluent/plugin_support/udp_server'
+
+require 'yajl'
+
+module Fluent::Plugin
+  class SyslogInput < Fluent::Plugin::Input
+    include Fluent::PluginSupport::UDPServer
+    include Fluent::PluginSupport::TCPServer
+
+    Fluent::Plugin.register_input('syslog', self)
 
     SYSLOG_REGEXP = /^\<([0-9]+)\>(.*)/
 
@@ -58,75 +68,66 @@ class SyslogInput < Input
       7  => 'debug'
     }
 
-    def initialize
-      super
-      require 'cool.io'
-      require 'fluent/plugin/socket_util'
-    end
-
     desc 'The port to listen to.'
-    config_param :port, :integer, :default => 5140
+    config_param :port, :integer, default: 5140
     desc 'The bind address to listen to.'
-    config_param :bind, :string, :default => '0.0.0.0'
+    config_param :bind, :string, default: '0.0.0.0'
     desc 'The prefix of the tag. The tag itself is generated by the tag prefix, facility level, and priority.'
     config_param :tag, :string
     desc 'The transport protocol used to receive logs.(udp, tcp)'
-    config_param :protocol_type, :default => :udp do |val|
+    config_param :protocol_type, default: :udp do |val|
       case val.downcase
       when 'tcp'
         :tcp
       when 'udp'
         :udp
       else
-        raise ConfigError, "syslog input protocol type should be 'tcp' or 'udp'"
+        raise Fluent::ConfigError, "syslog input protocol type should be 'tcp' or 'udp'"
       end
     end
     desc 'If true, add source host to event record.'
-    config_param :include_source_host, :bool, :default => false
+    config_param :include_source_host, :bool, default: false
     desc 'Specify key of source host when include_source_host is true.'
-    config_param :source_host_key, :string, :default => 'source_host'.freeze
-    config_param :blocking_timeout, :time, :default => 0.5
+    config_param :source_host_key, :string, default: 'source_host'.freeze
 
     def configure(conf)
       super
 
+      receive_data_method = nil
+
       if conf.has_key?('format')
-        @parser = Plugin.new_parser(conf['format'])
+        @parser = Fluent::Plugin.new_parser(conf['format'])
         @parser.configure(conf)
+        receive_data_method = method(:receive_data_parser)
       else
         conf['with_priority'] = true
-        @parser = TextParser::SyslogParser.new
+        @parser = Fluent::TextParser::SyslogParser.new
         @parser.configure(conf)
         @use_default = true
+        receive_data_method = method(:receive_data_default)
       end
-    end
 
-    def start
-      callback = if @use_default
-                   method(:receive_data)
-                 else
-                   method(:receive_data_parser)
-                 end
-
-      @loop = Coolio::Loop.new
-      @handler = listen(callback)
-      @loop.attach(@handler)
-
-      @thread = Thread.new(&method(:run))
+      (class << self; self; end).module_eval do
+        define_method(:receive_data, receive_data_method)
+      end
     end
 
-    def shutdown
-      @loop.watchers.each {|w| w.detach }
-      @loop.stop
-      @handler.close
-      @thread.join
-    end
+    def start
+      super
 
-    def run
-      @loop.run(@blocking_timeout)
-    rescue
-      log.error "unexpected error", :error=>$!.to_s
-      log.error_backtrace
+      if @protocol_type == :udp
+        udp_server_read(port: @port, bind: @bind, size_limit: 4096) do |remote_addr, remote_port, data| # UDP 1 data is 1 line
+          data.chomp!
+          receive_data(data, remote_addr)
+        end
+      else
+        # syslog family add "\n" to each message and this seems only way to split messages in tcp/udp stream
+        tcp_server_listen(port: @port, bind: @bind, keepalive: false) do |conn|
+          conn.on_data(delimiter: "\n") do |line|
+            receive_data(line, conn.remote_addr)
+          end
+        end
+      end
     end
 
     private
@@ -140,50 +141,36 @@ def receive_data_parser(data, addr)
       pri = m[1].to_i
       text = m[2]
 
-      @parser.parse(text) { |time, record|
+      @parser.parse(text) do |time, record|
         unless time && record
           log.warn "pattern not match: #{text.inspect}"
           return
         end
 
-        record[@source_host_key] = addr[2] if @include_source_host
+        record[@source_host_key] = addr if @include_source_host
         emit(pri, time, record)
-      }
+      end
     rescue => e
       log.error data.dump, :error => e.to_s
       log.error_backtrace
     end
 
-    def receive_data(data, addr)
-      @parser.parse(data) { |time, record|
+    def receive_data_default(data, addr)
+      @parser.parse(data) do |time, record|
         unless time && record
-          log.warn "invalid syslog message", :data => data
+          log.warn "invalid syslog message", data: data
           return
         end
 
         pri = record.delete('pri')
-        record[@source_host_key] = addr[2] if @include_source_host
+        record[@source_host_key] = addr if @include_source_host
         emit(pri, time, record)
-      }
+      end
     rescue => e
-      log.error data.dump, :error => e.to_s
+      log.error data.dump, error: e.to_s
       log.error_backtrace
     end
 
-    private
-
-    def listen(callback)
-      log.info "listening syslog socket on #{@bind}:#{@port} with #{@protocol_type}"
-      if @protocol_type == :udp
-        @usock = SocketUtil.create_udp_socket(@bind)
-        @usock.bind(@bind, @port)
-        SocketUtil::UdpHandler.new(@usock, log, 2048, callback)
-      else
-        # syslog family add "\n" to each message and this seems only way to split messages in tcp stream
-        Coolio::TCPServer.new(@bind, @port, SocketUtil::TcpHandler, log, "\n", callback)
-      end
-    end
-
     def emit(pri, time, record)
       facility = FACILITY_MAP[pri >> 3]
       priority = PRIORITY_MAP[pri & 0b111]
@@ -192,7 +179,7 @@ def emit(pri, time, record)
 
       router.emit(tag, time, record)
     rescue => e
-      log.error "syslog failed to emit", :error => e.to_s, :error_class => e.class.to_s, :tag => tag, :record => Yajl.dump(record)
+      log.error "syslog failed to emit", error: e.to_s, error_class: e.class.to_s, tag: tag, record: Yajl.dump(record)
     end
   end
 end
diff --git a/lib/fluent/plugin/in_tcp.rb b/lib/fluent/plugin/in_tcp.rb
index 5993d95052..c56448e55d 100644
--- a/lib/fluent/plugin/in_tcp.rb
+++ b/lib/fluent/plugin/in_tcp.rb
@@ -14,19 +14,51 @@
 #    limitations under the License.
 #
 
-require 'fluent/plugin/socket_util'
+require 'fluent/plugin_support/tcp_server'
+require 'fluent/parser'
 
-module Fluent
-  class TcpInput < SocketUtil::BaseInput
-    Plugin.register_input('tcp', self)
+module Fluent::Plugin
+  class TcpInput < Fluent::Plugin::Input
+    include Fluent::PluginSupport::TCPServer
 
-    config_set_default :port, 5170
+    Fluent::Plugin.register_input('tcp', self)
+
+    desc 'Tag of output events.'
+    config_param :tag, :string
+    desc 'The format of the payload.'
+    config_param :format, :string
+    desc 'The port to listen to.'
+    config_param :port, :integer, default: 5170
+    desc 'The bind address to listen to.'
+    config_param :bind, :string, default: '0.0.0.0'
+    desc "The field name of the client's hostname."
+    config_param :source_host_key, :string, default: nil
     desc 'The payload is read up to this character.'
-    config_param :delimiter, :string, :default => "\n" # syslog family add "\n" to each message and this seems only way to split messages in tcp stream
+    config_param :delimiter, :string, default: "\n" # syslog family add "\n" to each message and this seems only way to split messages in tcp stream
+
+    def configure(conf)
+      super
+
+      @parser = Fluent::Plugin.new_parser(@format)
+      @parser.configure(conf)
+    end
+
+    def start
+      super
+
+      tcp_server_listen(port: @port, bind: @bind, keepalive: false) do |conn|
+        conn.on_data(delimiter: @delimiter) do |msg|
+          @parser.parse(msg) do |time, record|
+            unless time && record
+              log.warn "pattern not match: #{msg.inspect}"
+              return
+            end
 
-    def listen(callback)
-      log.info "listening tcp socket on #{@bind}:#{@port}"
-      Coolio::TCPServer.new(@bind, @port, SocketUtil::TcpHandler, log, @delimiter, callback)
+            record[@source_host_key] = addr[3] if @source_host_key
+            router.emit(@tag, time, record)
+          end
+        end
+      end
     end
   end
 end
diff --git a/lib/fluent/plugin/in_udp.rb b/lib/fluent/plugin/in_udp.rb
index d07ef6cc86..16bb10b10c 100644
--- a/lib/fluent/plugin/in_udp.rb
+++ b/lib/fluent/plugin/in_udp.rb
@@ -14,20 +14,50 @@
 #    limitations under the License.
 #
 
-require 'fluent/plugin/socket_util'
+require 'fluent/plugin_support/udp_server'
+require 'fluent/parser'
 
-module Fluent
-  class UdpInput < SocketUtil::BaseInput
-    Plugin.register_input('udp', self)
+module Fluent::Plugin
+  class UdpInput < Fluent::Plugin::Input
+    include Fluent::PluginSupport::UDPServer
 
-    config_set_default :port, 5160
-    config_param :body_size_limit, :size, :default => 4096
+    Fluent::Plugin.register_input('udp', self)
 
-    def listen(callback)
-      log.info "listening udp socket on #{@bind}:#{@port}"
-      @usock = SocketUtil.create_udp_socket(@bind)
-      @usock.bind(@bind, @port)
-      SocketUtil::UdpHandler.new(@usock, log, @body_size_limit, callback)
+    desc 'Tag of output events.'
+    config_param :tag, :string
+    desc 'The format of the payload.'
+    config_param :format, :string
+    desc 'The port to listen to.'
+    config_param :port, :integer, default: 5160
+    desc 'The bind address to listen to.'
+    config_param :bind, :string, default: '0.0.0.0'
+    desc "The field name of the client's hostname."
+    config_param :source_host_key, :string, default: nil
+    desc "The body size limit in UDP packet"
+    config_param :body_size_limit, :size, default: 4096
+
+    def configure(conf)
+      super
+
+      @parser = Fluent::Plugin.new_parser(@format)
+      @parser.configure(conf)
+    end
+
+    def start
+      super
+
+      udp_server_read(port: @port, bind: @bind, size_limit: @body_size_limit) do |remote_addr, remote_port, data| # UDP 1 data is 1 line
+        @parser.parse(data) do |time, record|
+          data.chomp!
+          unless time && record
+            log.warn "pattern not match: #{data.inspect}"
+            return
+          end
+
+          record[@source_host_key] = remote_host if @source_host_key
+          router.emit(@tag, time, record)
+        end
+      end
     end
   end
 end
diff --git a/lib/fluent/plugin/input.rb b/lib/fluent/plugin/input.rb
new file mode 100644
index 0000000000..3e20246d9e
--- /dev/null
+++ b/lib/fluent/plugin/input.rb
@@ -0,0 +1,54 @@
+#
+# Fluentd
+#
+#    Licensed under the Apache License, Version 2.0 (the "License");
+#    you may not use this file except in compliance with the License.
+#    You may obtain a copy of the License at
+#
+#        http://www.apache.org/licenses/LICENSE-2.0
+#
+#    Unless required by applicable law or agreed to in writing, software
+#    distributed under the License is distributed on an "AS IS" BASIS,
+#    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+#    See the License for the specific language governing permissions and
+#    limitations under the License.
+#
+
+require 'fluent/plugin/base'
+require 'fluent/plugin_support/emitter'
+
+module Fluent
+  module Plugin
+    class Input < Base
+      include Fluent::PluginSupport::Emitter
+
+      def initialize
+        super
+      end
+
+      def configure(conf)
+        super
+      end
+
+      def start
+        super
+      end
+
+      def stop
+        super
+      end
+
+      def shutdown
+        super
+      end
+
+      def close
+        super
+      end
+
+      def terminate
+        super
+      end
+    end
+  end
+end
diff --git a/lib/fluent/plugin/object_buffered_output.rb b/lib/fluent/plugin/object_buffered_output.rb
new file mode 100644
index 0000000000..d24512a331
--- /dev/null
+++ b/lib/fluent/plugin/object_buffered_output.rb
@@ -0,0 +1,78 @@
+#
+# Fluentd
+#
+#    Licensed under the Apache License, Version 2.0 (the "License");
+#    you may not use this file except in compliance with the License.
+#    You may obtain a copy of the License at
+#
+#        http://www.apache.org/licenses/LICENSE-2.0
+#
+#    Unless required by applicable law or agreed to in writing, software
+#    distributed under the License is distributed on an "AS IS" BASIS,
+#    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+#    See the License for the specific language governing permissions and
+#    limitations under the License.
+#
+
+require 'fluent/plugin/buffered_output'
+
+module Fluent
+  module Plugin
+    class ObjectBufferedOutput < BufferedOutput
+      # TODO check this works well w/ new API, or not
+      desc "Format times to integer, instead of event-time object"
+      config_param :time_as_integer, :bool, :default => true
+
+      config_param :tag_chunked, :bool, default: true # actually, always true (this configuration value is ignored)
+
+      def configure(conf)
+        super
+
+        if @time_as_integer
+          m = method(:format_stream_forced_integer)
+          (class << self; self; end).module_eval do
+            define_method(:format_stream, m)
+          end
+        end
+      end
+
+      def write_objects(chunk)
+        raise NotImplementedError
+      end
+
+      def metadata(tag)
+        @buffer.metadata(tag: tag)
+      end
+
+      def format_stream_forced_integer(tag, es)
+        es.to_msgpack_stream_forced_integer
+      end
+
+      def format_stream(tag, es)
+        es.to_msgpack_stream
+      end
+
+      def write(chunk)
+        chunk.extend(BufferedEventStreamMixin)
+        write_objects(chunk)
+      end
+
+      module BufferedEventStreamMixin
+        include Enumerable
+
+        def repeatable?
+          true
+        end
+
+        def each(&block)
+          msgpack_each(&block)
+        end
+
+        def to_msgpack_stream
+          read
+        end
+      end
+    end
+  end
+end
+
diff --git a/lib/fluent/plugin/out_copy.rb b/lib/fluent/plugin/out_copy.rb
index 6a0ec95086..c8c8bf032c 100644
--- a/lib/fluent/plugin/out_copy.rb
+++ b/lib/fluent/plugin/out_copy.rb
@@ -14,6 +14,8 @@
 #    limitations under the License.
 #
 
+require 'fluent/output'
+
 module Fluent
   class CopyOutput < MultiOutput
     Plugin.register_output('copy', self)
diff --git a/lib/fluent/plugin/output.rb b/lib/fluent/plugin/output.rb
new file mode 100644
index 0000000000..bb3bbdfe59
--- /dev/null
+++ b/lib/fluent/plugin/output.rb
@@ -0,0 +1,65 @@
+#
+# Fluentd
+#
+#    Licensed under the Apache License, Version 2.0 (the "License");
+#    you may not use this file except in compliance with the License.
+#    You may obtain a copy of the License at
+#
+#        http://www.apache.org/licenses/LICENSE-2.0
+#
+#    Unless required by applicable law or agreed to in writing, software
+#    distributed under the License is distributed on an "AS IS" BASIS,
+#    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+#    See the License for the specific language governing permissions and
+#    limitations under the License.
+#
+
+require 'fluent/plugin/base'
+
+module Fluent
+  module Plugin
+    class Output < Base
+      # config_param ...
+
+      def emit(tag, es)
+        raise NotImplementedError, "BUG: output plugins MUST implement this method"
+      end
+
+      def initialize
+        super
+      end
+
+      def configure(conf)
+        super
+      end
+
+      def start
+        super
+      end
+
+      def stop
+        super
+      end
+
+      def before_shutdown
+        super
+      end
+
+      def shutdown
+        super
+      end
+
+      def close
+        super
+      end
+
+      def terminate
+        super
+      end
+
+      def inspect
+        "#<%s:%014x>" % [self.class.name, '0x%014x' % (__id__ << 1)]
+      end
+    end
+  end
+end
diff --git a/lib/fluent/plugin/socket_util.rb b/lib/fluent/plugin/socket_util.rb
index 0f1e1496a7..c6c58994bb 100644
--- a/lib/fluent/plugin/socket_util.rb
+++ b/lib/fluent/plugin/socket_util.rb
@@ -17,6 +17,8 @@
 require 'cool.io'
 
 module Fluent
+  # Obsolete in v0.14
+  #   Use TCPServer / UDPServer of PluginSupport instead
   module SocketUtil
     def create_udp_socket(host)
       require 'ipaddr'
@@ -29,6 +31,7 @@ def create_udp_socket(host)
     end
     module_function :create_udp_socket
 
+    # obsolete in v0.14
     class UdpHandler < Coolio::IO
       def initialize(io, log, body_size_limit, callback)
         super(io)
@@ -47,6 +50,7 @@ def on_readable
       end
     end
 
+    # obsolete in v0.14
     class TcpHandler < Coolio::Socket
       PEERADDR_FAILED = ["?", "?", "name resolusion failed", "?"]
 
@@ -88,6 +92,7 @@ def on_close
       end
     end
 
+    # obsolete in v0.14
     class BaseInput < Fluent::Input
       def initialize
         super
diff --git a/lib/fluent/plugin/time_sliced_output.rb b/lib/fluent/plugin/time_sliced_output.rb
new file mode 100644
index 0000000000..5d98636db4
--- /dev/null
+++ b/lib/fluent/plugin/time_sliced_output.rb
@@ -0,0 +1,129 @@
+#
+# Fluentd
+#
+#    Licensed under the Apache License, Version 2.0 (the "License");
+#    you may not use this file except in compliance with the License.
+#    You may obtain a copy of the License at
+#
+#        http://www.apache.org/licenses/LICENSE-2.0
+#
+#    Unless required by applicable law or agreed to in writing, software
+#    distributed under the License is distributed on an "AS IS" BASIS,
+#    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+#    See the License for the specific language governing permissions and
+#    limitations under the License.
+#
+
+require 'fluent/plugin/buffered_output'
+require 'fluent/timezone'
+
+module Fluent
+  module Plugin
+    class TimeSlicedOutput < BufferedOutput
+      DEFAULT_CHUNK_BYTES_LIMIT = 256 * 1024 * 1024 # 256MB for file
+
+      desc 'The time format used as part of the file name.'
+      config_param :time_slice_format, :string, default: '%Y%m%d'
+      desc 'The amount of time Fluentd will wait for old logs to arrive.'
+      config_param :time_slice_wait, :time, default: 10*60
+
+      desc 'Parse the time value in the specified timezone'
+      config_param :timezone, :string, default: nil # most authoritive if specified
+      config_param :localtime, :bool, default: true # localtime and utc are exclusive
+      config_param :utc, :bool, default: false
+
+      config_section :buffer, param_name: :buffer_config do
+        config_set_default :type, 'file' # overwrite default buffer_type
+        config_set_default :chunk_bytes_limit, DEFAULT_CHUNK_BYTES_LIMIT
+        config_set_default :flush_interval, nil
+      end
+
+      attr_reader :time_slicer # for test
+
+      def configure(conf)
+        super
+
+        if @timezone
+          Fluent::Timezone.validate!(@timezone)
+          @time_slicer = Timezone.formatter(@timezone, @time_slice_format)
+        else
+          if @utc
+            @localtime = false # if utc is set true explicitly, @localtime should be false
+          elsif !@localtime # if localtime is set false explicitly, @utc should be true
+            @utc = true
+          end
+
+          if @localtime
+            @time_slicer = Proc.new {|time|
+              Time.at(time).strftime(@time_slice_format)
+            }
+          else # UTC
+            @time_slicer = Proc.new {|time|
+              Time.at(time).utc.strftime(@time_slice_format)
+            }
+          end
+        end
+
+        @time_slice_cache_interval = time_slice_cache_interval
+        @before_tc = nil
+        @before_key = nil
+
+        @flush_interval = @buffer_config.flush_interval
+
+        if @flush_interval
+          if @time_slice_wait
+            log.warn "time_slice_wait is ignored if flush_interval is specified"
+          end
+          @chunk_enqueue_rule = ->(chunk){ chunk.created_at + @flush_interval > Time.now }
+        else
+          @flush_interval = [60, @time_slice_cache_interval].min
+          @chunk_enqueue_rule = ->(chunk){
+            current_slice = @time_slicer.call(Time.now.to_i - @time_slice_wait)
+            chunk.metadata.timekey < current_slice
+          }
+        end
+      end
+
+      def metadata(timekey, tag)
+        @tag_chunked ? @buffer.metadata(timekey: timekey, tag: tag) : @buffer.metadata(timekey: timekey)
+      end
+
+      def handle_stream(tag, es)
+        @emit_count += 1
+        emitted_meta = {}
+
+        es.each do |time, record|
+          ts = time / @time_slice_cache_interval
+          timekey = if @before_tc == ts # same time_slice with event just before
+                      @before_key
+                    else # new time_slice, so update cache by calling @time_slicer (heavy)
+                      @before_tc = ts
+                      @before_key = @time_slicer.call(time)
+                    end
+          data = format(tag, time, record)
+          meta = metadata
+          @buffer.emit(meta, data)
+          emitted_meta[meta] = true
+        end
+
+        emitted_meta.keys
+      end
+
+      def enqueue_buffer(force: false, test: nil)
+        super(force: force, test: @chunk_enqueue_rule)
+      end
+
+      def time_slice_cache_interval
+        if @time_slicer.call(0) != @time_slicer.call(60-1) # time slice length is seconds (1-59)
+          1
+        elsif @time_slicer.call(0) != @time_slicer.call(60*60-1) # time slice length is minutes
+          30
+        elsif @time_slicer.call(0) != @time_slicer.call(24*60*60-1) # time slice length is hours
+          60*30
+        else # longer than day
+          24*60*30
+        end
+      end
+    end
+  end
+end
diff --git a/lib/fluent/plugin_id.rb b/lib/fluent/plugin_id.rb
new file mode 100644
index 0000000000..fc544b6d41
--- /dev/null
+++ b/lib/fluent/plugin_id.rb
@@ -0,0 +1,45 @@
+#
+# Fluent
+#
+#    Licensed under the Apache License, Version 2.0 (the "License");
+#    you may not use this file except in compliance with the License.
+#    You may obtain a copy of the License at
+#
+#        http://www.apache.org/licenses/LICENSE-2.0
+#
+#    Unless required by applicable law or agreed to in writing, software
+#    distributed under the License is distributed on an "AS IS" BASIS,
+#    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+#    See the License for the specific language governing permissions and
+#    limitations under the License.
+#
+
+require 'fluent/configurable'
+
+module Fluent
+  module PluginId
+    @@_id_configured = {}
+
+    def configure(conf)
+      @id = conf['@id'] || conf['id']
+      @_id_configured = !!@id # plugin id is explicitly configured by users (or not)
+      if @@_id_configured[@id]
+        raise Fluent::ConfigError, "Duplicated plugin id `#{@id}`. Check whole configuration and fix it."
+      end
+      @@configured_ids[@id] = self
+      super
+    end
+
+    def plugin_id_configured?
+      @_id_configured
+    end
+
+    def plugin_id
+      @id ? @id : "object:#{object_id.to_s(16)}"
+    end
+
+    def configured_plugin_id
+      @_id_configured && @id || nil
+    end
+  end
+end
diff --git a/lib/fluent/plugin_support.rb b/lib/fluent/plugin_support.rb
new file mode 100644
index 0000000000..6078798c9f
--- /dev/null
+++ b/lib/fluent/plugin_support.rb
@@ -0,0 +1,20 @@
+#
+# Fluentd
+#
+#    Licensed under the Apache License, Version 2.0 (the "License");
+#    you may not use this file except in compliance with the License.
+#    You may obtain a copy of the License at
+#
+#        http://www.apache.org/licenses/LICENSE-2.0
+#
+#    Unless required by applicable law or agreed to in writing, software
+#    distributed under the License is distributed on an "AS IS" BASIS,
+#    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+#    See the License for the specific language governing permissions and
+#    limitations under the License.
+#
+
+require 'fluent/plugin_support/child_process'
+require 'fluent/plugin_support/timer'
+require 'fluent/plugin_support/thread'
+require 'fluent/plugin_support/socket' # TODO: just socket? Or tcp_socket, udp_socket, unix_socket & ssl_socket?
diff --git a/lib/fluent/plugin_support/child_process.rb b/lib/fluent/plugin_support/child_process.rb
new file mode 100644
index 0000000000..c5a459e009
--- /dev/null
+++ b/lib/fluent/plugin_support/child_process.rb
@@ -0,0 +1,167 @@
+#
+# Fluentd
+#
+#    Licensed under the Apache License, Version 2.0 (the "License");
+#    you may not use this file except in compliance with the License.
+#    You may obtain a copy of the License at
+#
+#        http://www.apache.org/licenses/LICENSE-2.0
+#
+#    Unless required by applicable law or agreed to in writing, software
+#    distributed under the License is distributed on an "AS IS" BASIS,
+#    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+#    See the License for the specific language governing permissions and
+#    limitations under the License.
+#
+
+require 'fluent/plugin_support/thread'
+require 'fluent/plugin_support/timer'
+
+module Fluent
+  module PluginSupport
+    module ChildProcess
+      include Fluent::PluginSupport::Thread
+      include Fluent::PluginSupport::Timer
+
+      CHILD_PROCESS_LOOP_CHECK_INTERVAL = 0.2 # sec
+      CHILD_PROCESS_DEFAULT_KILL_TIMEOUT = 60 # sec
+
+      def child_process_execute(command:, arguments: nil, subprocess_name: nil, read: true, write: true, encoding: 'utf-8', interval: nil, immediate: false, &block)
+        raise "BUG: illegal specification to disable both of input and output file handle" if !read && !write
+        raise "BUG: block not specified which receive i/o object" unless block_given?
+
+        if interval
+          if immediate
+            child_process_execute_once(command, arguments, subprocess_name, read, write, encoding, &block)
+          end
+          timer_execute(interval: interval, repeat: true) do
+            child_process_execute_once(command, arguments, subprocess_name, read, write, encoding, &block)
+          end
+        else
+          child_process_execute_once(command, arguments, subprocess_name, read, write, encoding, &block)
+        end
+      end
+
+      def initialize
+        super
+      end
+
+      def start
+        super
+        @_child_process_processes = {} # pid => thread
+      end
+
+      def stop
+        super
+      end
+
+      def shutdown
+        @_child_process_processes.keys.each do |pid|
+          process_alive = true
+          begin
+            if Process.waitpid(pid, Process::WNOHANG)
+              Process.kill(:TERM, pid)
+              process_alive = false
+            end
+          rescue
+            # Errno::ECHILD, Errno::ESRCH, Errno::EPERM
+            # child process already doesn't exist
+            process_alive = false
+          end
+          unless process_alive
+            begin
+              @_child_process_processes[pid][:io].close
+            rescue
+              # ignore
+            end
+            @_child_process_processes.delete(pid)
+          end
+        end
+
+        super
+      end
+
+      def close
+        super
+
+        @_child_process_processes.keys.each do |pid|
+          io = @_child_process_processes[pid][:io]
+          begin
+            io.close
+          rescue => e
+            # just ignore
+          end
+        end
+      end
+
+      def terminate
+        @_child_process_processes.keys.each do |pid|
+          begin
+            Process.kill(:KILL, pid)
+          rescue
+            # ignore even if process already doesn't exist
+          end
+          @_child_process_processes.delete(pid)
+        end
+
+        super
+      end
+
+      # for private use
+      def child_process_execute_once(command, arguments, subprocess_name, read, write, encoding, &block)
+        ext_enc = encoding
+        int_enc = "utf-8"
+        mode = case
+               when read && write then "r+"
+               when read then "r"
+               when write then "w"
+               else "r" # but it is not for any bytes
+               end
+        cmd = command
+        if arguments # if arguments is nil, then command is executed by shell
+          cmd = []
+          if subprocess_name
+            cmd.push [command, subprocess_name]
+          else
+            cmd.push command
+          end
+          cmd += arguments
+        end
+        io = IO.popen(cmd, mode, external_encoding: ext_enc, internal_encoding: int_enc)
+        pid = io.pid
+
+        thread = thread_create do
+          begin
+            block.call(io) # TODO: rescue and log? or kill entire process?
+          rescue EOFError => e
+            # io closed (process exit)
+            ## TODO: log
+          rescue IOError => e
+            raise unless e.message == 'stream closed'
+            ## TODO: log
+          end
+
+          # child process probablly ended if sequence reaches here
+          begin
+            while thread_current_running? && Process.waitpid(pid, Process::WNOHANG)
+              sleep CHILD_PROCESS_LOOP_CHECK_INTERVAL
+            end
+            if Process.waitpid(pid, Process::WNOHANG)
+              Process.kill(:TERM, pid)
+            end
+          rescue Errno::ECHILD, Errno::ESRCH => e
+            # child process already died
+          end
+          begin
+            io.close
+          rescue => e
+            # ignore all errors because io already isn't connected anywhere
+          end
+          @_child_process_processes.delete(pid)
+        end
+
+        @_child_process_processes[pid] = {thread: thread, io: io}
+      end
+    end
+  end
+end
diff --git a/lib/fluent/plugin_support/emitter.rb b/lib/fluent/plugin_support/emitter.rb
new file mode 100644
index 0000000000..4a0e773c0f
--- /dev/null
+++ b/lib/fluent/plugin_support/emitter.rb
@@ -0,0 +1,52 @@
+#
+# Fluentd
+#
+#    Licensed under the Apache License, Version 2.0 (the "License");
+#    you may not use this file except in compliance with the License.
+#    You may obtain a copy of the License at
+#
+#        http://www.apache.org/licenses/LICENSE-2.0
+#
+#    Unless required by applicable law or agreed to in writing, software
+#    distributed under the License is distributed on an "AS IS" BASIS,
+#    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+#    See the License for the specific language governing permissions and
+#    limitations under the License.
+#
+
+require 'fluent/engine'
+
+module Fluent
+  module PluginSupport
+    module Emitter
+      attr_accessor :router
+
+      def initialize
+        super
+        @router = nil
+      end
+
+      def configure(conf)
+        super
+
+        if label_name = conf['@label']
+          label = Engine.root_agent.find_label(label_name)
+          @router = label.event_router
+        elsif @router.nil?
+          @router = Engine.root_agent.event_router
+        end
+      end
+
+      def emits?
+        true
+      end
+
+      def shutdown
+        super
+
+        # TODO: disable @router
+      end
+    end
+  end
+end
+
diff --git a/lib/fluent/plugin_support/event_loop.rb b/lib/fluent/plugin_support/event_loop.rb
new file mode 100644
index 0000000000..5d74e207a4
--- /dev/null
+++ b/lib/fluent/plugin_support/event_loop.rb
@@ -0,0 +1,107 @@
+#
+# Fluentd
+#
+#    Licensed under the Apache License, Version 2.0 (the "License");
+#    you may not use this file except in compliance with the License.
+#    You may obtain a copy of the License at
+#
+#        http://www.apache.org/licenses/LICENSE-2.0
+#
+#    Unless required by applicable law or agreed to in writing, software
+#    distributed under the License is distributed on an "AS IS" BASIS,
+#    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+#    See the License for the specific language governing permissions and
+#    limitations under the License.
+#
+
+require 'cool.io'
+require 'fluent/plugin_support/thread'
+
+module Fluent
+  module PluginSupport
+    module EventLoop
+      include Fluent::PluginSupport::Thread
+
+      EVENT_LOOP_RUN_DEFAULT_TIMEOUT = 0.2
+
+      def event_loop_attach(watcher)
+        @_event_loop_mutex.synchronize do
+          @_event_loop.attach(watcher)
+        end
+      end
+
+      def event_loop_running?
+        @_event_loop_running
+      end
+
+      def initialize
+        super
+        @_event_loop = Coolio::Loop.new
+        @_event_loop_running = false
+        @_event_loop_mutex = Mutex.new
+        @_event_loop_run_timeout = EVENT_LOOP_RUN_DEFAULT_TIMEOUT
+      end
+
+      def configure(conf)
+        super
+      end
+
+      class DefaultWatcher < Coolio::TimerWatcher
+        def initialize
+          super(1, true) # interval: 1, repeat: true
+        end
+        # do nothing
+        def on_timer; end
+      end
+
+      def start
+        super
+
+        # event loop does not run here, so mutex lock is not required
+        thread_create do
+          default_watcher = DefaultWatcher.new
+          @_event_loop.attach( default_watcher )
+
+          @_event_loop_running = true
+
+          @_event_loop.run( @_event_loop_run_timeout ) # this method blocks
+
+          @_event_loop_running = false
+        end
+      end
+
+      def stop
+        super
+      end
+
+      def shutdown
+        @_event_loop_mutex.synchronize do
+          @_event_loop.watchers.each {|w| w.detach if w.attached? }
+        end
+
+        super
+      end
+
+      def close
+        if @_event_loop_running
+          begin
+            @_event_loop.stop # we cannot check loop is running or not
+          rescue RuntimeError => e
+            raise if e.message != 'loop not running'
+          end
+        end
+
+        super
+      end
+
+      def terminate
+        @_event_loop = nil
+        @_event_loop_running = false
+        @_event_loop_mutex = nil
+        @_event_loop_run_timeout = EVENT_LOOP_RUN_DEFAULT_TIMEOUT
+
+        super
+      end
+    end
+  end
+end
diff --git a/lib/fluent/plugin_support/socket.rb b/lib/fluent/plugin_support/socket.rb
new file mode 100644
index 0000000000..ace596108a
--- /dev/null
+++ b/lib/fluent/plugin_support/socket.rb
@@ -0,0 +1,49 @@
+#
+# Fluentd
+#
+#    Licensed under the Apache License, Version 2.0 (the "License");
+#    you may not use this file except in compliance with the License.
+#    You may obtain a copy of the License at
+#
+#        http://www.apache.org/licenses/LICENSE-2.0
+#
+#    Unless required by applicable law or agreed to in writing, software
+#    distributed under the License is distributed on an "AS IS" BASIS,
+#    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+#    See the License for the specific language governing permissions and
+#    limitations under the License.
+#
+
+module Fluent
+  module PluginSupport
+    module Socket
+      SockInfo = Struct.new(:proto, :bind, :port)
+
+      attr_reader :_listener_states
+
+      def initialize
+        super
+        @_listeners = []
+        @_listener_states = {} # sock => running[bool]
+      end
+
+      def socket_listener_add(proto, bind, port)
+        sinfo = SockInfo.new(proto, bind, port)
+        @_listeners << sinfo
+        @_listener_states[sinfo] = false
+      end
+
+      def socket_listener_listen(proto, bind, port)
+        sinfo = @_listeners.find{|s| s.proto == proto && s.bind == bind && s.port == port }
+        raise "BUG: socket_listener_listen called without socket_listener_add, #{proto},#{bind},#{port}" unless sinfo
+        @_listener_states[sinfo] = true
+      end
+
+      def terminate
+        super
+        @_listeners = []
+        @_listener_states = {}
+      end
+    end
+  end
+end
diff --git a/lib/fluent/plugin_support/ssl_server.rb b/lib/fluent/plugin_support/ssl_server.rb
new file mode 100644
index 0000000000..9fd2e7fb15
--- /dev/null
+++ b/lib/fluent/plugin_support/ssl_server.rb
@@ -0,0 +1,347 @@
+#
+# Fluentd
+#
+#    Licensed under the Apache License, Version 2.0 (the "License");
+#    you may not use this file except in compliance with the License.
+#    You may obtain a copy of the License at
+#
+#        http://www.apache.org/licenses/LICENSE-2.0
+#
+#    Unless required by applicable law or agreed to in writing, software
+#    distributed under the License is distributed on an "AS IS" BASIS,
+#    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+#    See the License for the specific language governing permissions and
+#    limitations under the License.
+#
+
+require 'fluent/plugin_support/socket'
+require 'fluent/plugin_support/timer'
+
+require 'ipaddr'
+require 'socket'
+require 'openssl'
+require 'digest'
+require 'securerandom'
+
+module Fluent
+  module PluginSupport
+    module SSLServer
+      include Fluent::PluginSupport::Socket
+      include Fluent::PluginSupport::Thread
+      include Fluent::PluginSupport::Timer
+
+      SSL_SERVER_KEEPALIVE_CHECK_INTERVAL = 1
+      SSL_SERVER_DEFAULT_READ_LENGTH = 8 * 1024 * 1024
+      SSL_SERVER_DEFAULT_READ_INTERVAL = 0.05 # [s], 50ms
+      SSL_SERVER_DEFAULT_SOCKET_RESTART_INTERVAL = 0.2 # [s], 200ms
+
+      def ssl_server_generate_cert_key(ca_cert: nil, ca_key: nil, digest: OpenSSL::Digest::SHA256, algorithm: OpenSSL::PKey::RSA, key_length: 2048, cert_country: 'US', cert_state: 'CA', cert_locality: 'Mountain View', cert_common_name: "Fluentd #{self.class} SSLServer")
+        if ca_cert && !ca_key || !ca_cert && ca_key
+          raise ArgumentError, "ca_cert and ca_key should be both specified, or both not specified"
+        end
+
+        key = algorithm.generate(key_length)
+
+        subject = OpenSSL::X509::Name.new
+        issuer = ca_cert || subject # if @ca_cert is nil, then generate self-signed certificate
+
+        subject.add_entry('C', cert_country)
+        subject.add_entry('ST', cert_state)
+        subject.add_entry('L', cert_locality)
+        subject.add_entry('CN', cert_common_name)
+
+        cert = OpenSSL::X509::Certificate.new
+        cert.not_before = Time.at(0)
+        cert.not_after = Time.now + 86400 * 365 * 5
+        cert.public_key = key
+        cert.serial = 1
+        cert.issuer = issuer
+        cert.subject  = subject
+
+        digest_obj = digest.new
+
+        if ca_key
+          cert.sign(ca_key, digest_obj)
+        else
+          cert.sign(key, digest_obj)
+        end
+
+        return cert, key
+      end
+
+      def ssl_server_load_cert_key(cert_file_path:, algorithm: OpenSSL::PKey::RSA, key_file_path:, key_passphrase:)
+        cert = OpenSSL::X509::Certificate.new(File.read(cert_file_path))
+        key = algorithm.new(File.read(key_file_path), key_passphrase)
+        return cert, key
+      end
+
+      # keepalive: seconds, (default: nil [inf])
+      def ssl_server_listen(ssl_version: :TLSv1_2, ciphers: nil, cert:, key:, port:, bind: '0.0.0.0', keepalive: nil, linger_timeout: nil, backlog: nil, read_length: SSL_SERVER_DEFAULT_READ_LENGTH, read_interval: SSL_SERVER_KEEPALIVE_CHECK_INTERVAL, socket_restart_interval: SSL_SERVER_DEFAULT_SOCKET_RESTART_INTERVAL, &block)
+        raise "BUG: callback block is not specified for ssl_server_listen" unless block_given?
+        raise "BUG: specified SSL/TLS version '#{ssl_method}' is not supported in this environment" unless OpenSSL::SSL::SSLContext::METHODS.include?(ssl_version)
+        port = port.to_i
+
+        socket_listener_add('tcp', bind, port)
+
+        ctx = OpenSSL::SSL::SSLContext.new(ssl_version)
+
+        # inject OpenSSL::SSL::SSLContext::DEFAULT_PARAMS
+        # https://bugs.ruby-lang.org/issues/9424
+        ctx.set_params({})
+
+        ctx.cert = cert
+        ctx.key = key
+        if ciphers
+          ctx.ciphers = ciphers
+        else
+          ### follow httpclient configuration by nahi
+          # OpenSSL 0.9.8 default: "ALL:!ADH:!LOW:!EXP:!MD5:+SSLv2:@STRENGTH"
+          ctx.ciphers = "ALL:!aNULL:!eNULL:!SSLv2" # OpenSSL >1.0.0 default
+        end
+        ctx.timeout = keepalive || 86400 * 365 * 5 # 5 years is like infinity
+
+        if self.respond_to?(:detach_multi_process)
+          detach_multi_process do
+            ssl_server_listen_impl(bind, port, ctx, keepalive, linger_timeout, backlog, read_length, read_interval, socket_restart_interval, &block)
+          end
+        elsif self.respond_to?(:detach_process)
+          detach_process do
+            ssl_server_listen_impl(bind, port, ctx, keepalive, linger_timeout, backlog, read_length, read_interval, socket_restart_interval, &block)
+          end
+        else
+          ssl_server_listen_impl(bind, port, ctx, keepalive, linger_timeout, backlog, read_length, read_interval, socket_restart_interval, &block)
+        end
+      end
+
+      def initialize
+        super
+        @_ssl_server_listen_servers = []
+        @_ssl_server_listen_socks = []
+        @_ssl_server_listen_threads = []
+        @_ssl_server_connections = {}
+      end
+
+      def configure(conf)
+        super
+      end
+
+      def start
+        super
+        OpenSSL::Random.seed(SecureRandom.random_bytes(16))
+      end
+
+      def ssl_server_listen_impl(bind, port, ctx, keepalive, linger_timeout, backlog, read_length, read_interval, socket_restart_interval, &block)
+        register_new_connection = ->(conn){ @_ssl_server_connections[conn] = conn }
+
+        timer_execute(interval: SSL_SERVER_KEEPALIVE_CHECK_INTERVAL, repeat: true) do
+          # copy keys at first to delete it in loop
+          @_ssl_server_connections.keys.each do |conn|
+            if !conn.writing? && keepalive && conn.idle_seconds > keepalive
+              @_ssl_server_connections.delete(conn)
+              conn.close
+            elsif conn.closed?
+              @_ssl_server_connections.delete(conn)
+            else
+              conn.idle_seconds += SSL_SERVER_KEEPALIVE_CHECK_INTERVAL
+            end
+          end
+        end
+
+        listener_thread = thread_create do
+          server = ::TCPServer.new(bind, port)
+          if backlog
+            server.listen(backlog)
+          end
+          sock = OpenSSL::SSL::SSLServer.new(server, ctx)
+          # delay SSL session establishment not to do it when sock.accept
+          # SSL session establishment is heavy, and it should be executed on child thread
+          sock.start_immediately = false
+
+          @_ssl_server_listen_servers << server
+          @_ssl_server_listen_socks << sock
+
+          socket_listener_listen('tcp', bind, port)
+          while socket = sock.accept
+            if linger_timeout
+              opt = [1, linger_timeout].pack('I!I!')  # { int l_onoff; int l_linger; }
+              socket.setsockopt(::Socket::SOL_SOCKET, ::Socket::SO_LINGER, opt)
+            end
+            socket.sync = true
+            socket.sync_close = true
+            thread_create(socket) do |socket|
+              running_check = ->(){ thread_current_running? }
+              conn = Handler.new(socket, register_new_connection, running_check, read_length, read_interval, socket_restart_interval, block)
+              @_ssl_server_connections[conn] = conn
+              conn.run
+            end
+          end
+        end
+
+        @_ssl_server_listen_threads << listener_thread
+      end
+
+      def stop
+        super
+      end
+
+      def shutdown
+        super
+
+        # listen threads are blocking on accept. So killing them is an only way to stop it
+        @_ssl_server_listen_threads.each do |thread|
+          thread.kill
+          thread.join
+        end
+        @_ssl_server_listen_socks.each do |sock|
+          sock.close
+        end
+        @_ssl_server_listen_servers.each do |server|
+          server.close unless server.closed?
+        end
+      end
+
+      def close
+        @_ssl_server_connections.keys.each do |conn|
+          conn.close
+        end
+
+        super
+      end
+
+      def terminate
+        @_ssl_server_listen_servers = []
+        @_ssl_server_listen_socks = []
+        @_ssl_server_listen_threads = []
+        @_ssl_server_connections = {}
+
+        super
+      end
+
+      class Handler
+        attr_accessor :idle_seconds, :closing
+        attr_reader :protocol, :remote_port, :remote_addr, :remote_host
+
+        PEERADDR_FAILED = ["?", "?", "name resolusion failed", "?"]
+
+        def initialize(io, register, running_check, read_length, read_interval, socket_restart_interval, on_connect_callback)
+          @io = io
+
+          register.call(self)
+
+          @running_check = running_check
+          @read_length = read_length
+          @read_interval = read_interval
+          @socket_restart_interval = socket_restart_interval
+
+          @on_connect_callback = on_connect_callback
+          @on_read_callback = nil
+
+          @buffer = nil # for on_data with delimiter
+
+          @idle_seconds = 0
+          @closing = false
+          @writing = false
+        end
+
+        def run
+          socket = @io
+
+          begin
+            socket.accept
+          rescue OpenSSL::SSL::SSLError => e
+            # TODO: log
+            self.close rescue nil
+            return
+          end
+
+          ### TODO: disabling name rev resolv
+          proto, port, host, addr = ( socket.peeraddr rescue PEERADDR_FAILED )
+          if addr == '?'
+            port, addr = *Socket.unpack_sockaddr_in(socket.getpeername) rescue nil
+          end
+          @protocol = proto
+          @remote_port = port
+          @remote_addr = addr
+          @remote_host = host
+
+          @on_connect_callback.call(self)
+          raise "BUG: register on_data callback" unless @on_read_callback
+
+          @idle_seconds = 0
+          buf = ''
+          loop do
+            begin
+              buf = ''
+              while socket.read_nonblock(@read_length, buf)
+                if buf.empty?
+                  unless @running_check.call()
+                    break
+                  end
+                  @idle_seconds += @read_interval
+                  sleep @read_interval
+                  next
+                end
+                @on_read_callback.call(buf)
+                buf = ''
+              end
+            rescue OpenSSL::SSL::SSLErrorWaitReadable => e # read would block
+              buf = ''
+              sleep @socket_restart_interval
+            rescue EOFError => e
+              # TODO: log
+              break
+            rescue IOError => e
+              break if e.message == 'closed stream'
+            end
+          end
+        rescue Errno::ECONNRESET => e
+          # disconnected from client
+          # TODO: log
+        ensure
+          self.close rescue nil
+        end
+
+        # API to register callback for data arrival
+        def on_data(delimiter: nil, &callback)
+          if delimiter.nil?
+            @on_read_callback = callback
+          else # buffering and splitting
+            @buffer = "".force_encoding("ASCII-8BIT")
+            @on_read_callback = ->(data) {
+              @buffer << data
+              pos = 0
+              while i = @buffer.index(delimiter, pos)
+                msg = @buffer[pos...i]
+                callback.call(msg)
+                pos = i + delimiter.length
+              end
+              @buffer.slice!(0, pos) if pos > 0
+            }
+          end
+        end
+
+        def write(data)
+          @writing = true
+
+          @io.write data
+
+          @writing = false
+          if @closing
+            close
+          end
+        end
+
+        def writing?
+          @writing
+        end
+
+        def close
+          @closing = true
+          unless @writing
+            @io.close
+          end
+        end
+      end
+    end
+  end
+end
diff --git a/lib/fluent/plugin_support/storage.rb b/lib/fluent/plugin_support/storage.rb
new file mode 100644
index 0000000000..705b212e9e
--- /dev/null
+++ b/lib/fluent/plugin_support/storage.rb
@@ -0,0 +1,106 @@
+#
+# Fluentd
+#
+#    Licensed under the Apache License, Version 2.0 (the "License");
+#    you may not use this file except in compliance with the License.
+#    You may obtain a copy of the License at
+#
+#        http://www.apache.org/licenses/LICENSE-2.0
+#
+#    Unless required by applicable law or agreed to in writing, software
+#    distributed under the License is distributed on an "AS IS" BASIS,
+#    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+#    See the License for the specific language governing permissions and
+#    limitations under the License.
+#
+
+require 'fluent/storage'
+require 'fluent/plugin'
+require 'fluent/plugin_support/timer'
+require 'fluent/config/element'
+
+module Fluent
+  module PluginSupport
+    module Storage
+      attr_reader :storage
+
+      include Fluent::PluginSupport::Timer
+
+      def initialize
+        super
+        @storage = nil
+      end
+
+      def configure(conf)
+        storage_configs = conf.elements.select{|e| e.name == 'storage' }
+        original_conf_elements = conf.elements
+        conf.elements = conf.elements.reject{|e| e.name == 'storage' }
+        raise Fluent::ConfigError, "<storage> section appears more than once" if storage_configs.size > 1
+
+        super
+
+        # instanciate storage if `<storage>` section exists or <system> plugin_storage_path </system> specified and @id is specified
+        if storage_configs.size == 1 || (system_config.plugin_storage_path && plugin_id_configured?)
+          storage_config = storage_configs.first
+          type = nil
+          if storage_config
+            type = storage_config.type
+          else # /system-wide/specified/plugin-storage-path/json/@id.json
+            type = Fluent::Storage::DEFAULT_TYPE
+            default_path = File.join(system_config.plugin_storage_path, type, plugin_id + '.' + type)
+            storage_config = Fluent::Config::Element.new('storage', '', {'type' => type, 'path' => default_path}, [])
+          end
+
+          @storage = Fluent::Plugin.new_storage(type)
+          root = Fluent::Config::Element.new('STORAGE_ROOT', '', {}, [storage_config])
+          @storage.configure(root)
+
+          # restore original orders of elements
+          # to show configuration dump on logs
+          conf.elements = original_conf_elements
+        else
+          @storage = Fluent::Plugin.new_storage('memory')
+        end
+      end
+
+      def storage_save
+        begin
+          @storage.save
+        rescue => e
+          log.error "Failed to save plugin storage contents", storage: @storage.class, error_class: e.class, error: e.message
+        end
+      end
+
+      def start
+        super
+
+        @storage.load
+
+        if @storage.autosave?
+          timer_execute(interval: @storage.autosave_interval) do
+            storage_save
+          end
+        end
+      end
+
+      def stop
+        super
+        storage_save if @storage && @storage.save_at_shutdown?
+      end
+
+      def shutdown
+        super
+      end
+
+      def close
+        super
+        # save storage content once more to be updatable in shutdown sequence
+        storage_save if @storage && @storage.save_at_shutdown?
+      end
+
+      def terminate
+        super
+      end
+    end
+  end
+end
diff --git a/lib/fluent/plugin_support/tcp_server.rb b/lib/fluent/plugin_support/tcp_server.rb
new file mode 100644
index 0000000000..948829648a
--- /dev/null
+++ b/lib/fluent/plugin_support/tcp_server.rb
@@ -0,0 +1,215 @@
+#
+# Fluentd
+#
+#    Licensed under the Apache License, Version 2.0 (the "License");
+#    you may not use this file except in compliance with the License.
+#    You may obtain a copy of the License at
+#
+#        http://www.apache.org/licenses/LICENSE-2.0
+#
+#    Unless required by applicable law or agreed to in writing, software
+#    distributed under the License is distributed on an "AS IS" BASIS,
+#    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+#    See the License for the specific language governing permissions and
+#    limitations under the License.
+#
+
+require 'fluent/plugin_support/event_loop'
+require 'fluent/plugin_support/timer'
+require 'fluent/plugin_support/socket'
+
+require 'socket'
+require 'cool.io'
+
+module Fluent
+  module PluginSupport
+    module TCPServer
+      include Fluent::PluginSupport::EventLoop
+      include Fluent::PluginSupport::Timer
+      include Fluent::PluginSupport::Socket
+
+      TCP_SERVER_KEEPALIVE_CHECK_INTERVAL = 1
+
+      # keepalive: seconds, (default: nil [inf])
+      def tcp_server_listen(port:, bind: '0.0.0.0', keepalive: nil, linger_timeout: nil, backlog: nil, &block)
+        raise "BUG: callback block is not specified for tcp_server_listen" unless block_given?
+        port = port.to_i
+
+        socket_listener_add('tcp', bind, port)
+
+        bind_sock = ::TCPServer.new(bind, port)
+
+        if self.respond_to?(:detach_multi_process)
+          detach_multi_process do
+            tcp_server_listen_impl(bind, port, bind_sock, keepalive, linger_timeout, backlog, &block)
+          end
+        elsif self.respond_to?(:detach_process)
+          detach_process do
+            tcp_server_listen_impl(bind, port, bind_sock, keepalive, linger_timeout, backlog, &block)
+          end
+        else
+          tcp_server_listen_impl(bind, port, bind_sock, keepalive, linger_timeout, backlog, &block)
+        end
+      end
+
+      def initialize
+        super
+        @_tcp_server_listen_socks = []
+        @_tcp_server_connections = {}
+      end
+
+      def configure(conf)
+        super
+      end
+
+      def stop
+        super
+      end
+
+      def shutdown
+        @_tcp_server_listen_socks.each do |s|
+          s.detach if s.attached?
+        end
+        @_tcp_server_connections.keys.each do |sock|
+          sock.detach if sock.attached?
+        end
+
+        super
+      end
+
+      def close
+        @_tcp_server_connections.keys.each do |sock|
+          sock.close unless sock.closed?
+        end
+        @_tcp_server_listen_socks.each{|s| s.close }
+
+        super
+      end
+
+      def terminate
+        @_tcp_server_listen_socks = []
+        @_tcp_server_connections = {}
+
+        super
+      end
+
+      def tcp_server_listen_impl(bind, port, bind_sock, keepalive, linger_timeout, backlog, &block)
+        register_new_connection = ->(conn){ @_tcp_server_connections[conn] = conn }
+
+        timer_execute(interval: TCP_SERVER_KEEPALIVE_CHECK_INTERVAL, repeat: true) do
+          # copy keys at first (to delete it in loop)
+          @_tcp_server_connections.keys.each do |conn|
+            if !conn.writing? && keepalive && conn.idle_seconds > keepalive
+              @_tcp_server_connections.delete(conn)
+              conn.close
+            elsif conn.closed?
+              @_tcp_server_connections.delete(conn)
+            else
+              conn.idle_seconds += TCP_SERVER_KEEPALIVE_CHECK_INTERVAL
+            end
+          end
+        end
+
+        sock = Coolio::TCPServer.new(bind_sock, nil, Handler, register_new_connection, linger_timeout, block)
+        if backlog
+          sock.listen(backlog)
+        end
+        socket_listener_listen('tcp', bind, port)
+        event_loop_attach( sock )
+        @_tcp_server_listen_socks << sock
+      end
+
+      class Handler < Coolio::Socket
+        attr_accessor :idle_seconds, :closing
+        attr_reader :protocol, :remote_port, :remote_addr, :remote_host
+
+        PEERADDR_FAILED = ["?", "?", "name resolusion failed", "?"]
+
+        def initialize(io, register, linger_timeout, on_connect_callback)
+          super(io)
+
+          register.call(self)
+          @on_connect_callback = on_connect_callback
+          @on_read_callback = nil
+
+          @buffer = nil # for on_data with delimiter
+
+          @idle_seconds = 0
+          @closing = false
+          @writing = false
+
+          ### TODO: disabling name rev resolv
+          proto, port, host, addr = ( io.peeraddr rescue PEERADDR_FAILED )
+          if addr == '?'
+            port, addr = *Socket.unpack_sockaddr_in(io.getpeername) rescue nil
+          end
+          @protocol = proto
+          @remote_port = port
+          @remote_addr = addr
+          @remote_host = host
+
+          if linger_timeout
+            # SO_LINGER 0 to send RST rather than FIN to avoid lots of connections sitting in TIME_WAIT at src
+            opt = [1, linger_timeout].pack('I!I!')  # { int l_onoff; int l_linger; }
+            io.setsockopt(::Socket::SOL_SOCKET, ::Socket::SO_LINGER, opt)
+          end
+        end
+
+        def on_connect
+          @on_connect_callback.call(self)
+        end
+
+        # API to register callback for data arrival
+        def on_data(delimiter: nil, &callback)
+          if delimiter.nil?
+            @on_read_callback = callback
+          else # buffering and splitting
+            @buffer = "".force_encoding("ASCII-8BIT")
+            @on_read_callback = ->(data) {
+              @buffer << data
+              pos = 0
+              while i = @buffer.index(delimiter, pos)
+                msg = @buffer[pos...i]
+                callback.call(msg)
+                pos = i + delimiter.length
+              end
+              @buffer.slice!(0, pos) if pos > 0
+            }
+          end
+        end
+
+        def on_read(data)
+          @idle_seconds = 0
+          @on_read_callback.call(data)
+        rescue => e
+          close
+          #### TODO: error handling & logging
+          raise
+        end
+
+        def write(data)
+          @writing = true
+          super
+        end
+
+        def writing?
+          @writing
+        end
+
+        def on_write_complete
+          @writing = false
+          if @closing
+            close
+          end
+        end
+
+        def close
+          @closing = true
+          unless @writing
+            super
+          end
+        end
+      end
+    end
+  end
+end
diff --git a/lib/fluent/plugin_support/thread.rb b/lib/fluent/plugin_support/thread.rb
new file mode 100644
index 0000000000..079777315f
--- /dev/null
+++ b/lib/fluent/plugin_support/thread.rb
@@ -0,0 +1,94 @@
+#
+# Fluentd
+#
+#    Licensed under the Apache License, Version 2.0 (the "License");
+#    you may not use this file except in compliance with the License.
+#    You may obtain a copy of the License at
+#
+#        http://www.apache.org/licenses/LICENSE-2.0
+#
+#    Unless required by applicable law or agreed to in writing, software
+#    distributed under the License is distributed on an "AS IS" BASIS,
+#    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+#    See the License for the specific language governing permissions and
+#    limitations under the License.
+#
+
+module Fluent
+  module PluginSupport
+    module Thread
+      THREAD_DEFAULT_WAIT_SECONDS = 60
+
+      attr_reader :_threads # for test driver
+
+      def thread_current_running?
+        ::Thread.current[:_fluentd_plugin_support_thread_running] || false
+      end
+
+      def thread_create(*args)
+        thread = ::Thread.new(*args) do |*t_args|
+          current = ::Thread.current
+          current.abort_on_exception = true
+          ::Thread.current[:_fluentd_plugin_support_thread_running] = true
+          @_threads[current.object_id] = current
+          begin
+            yield *t_args
+          rescue => e # ThreadKilledError => e
+            ### TODO: log that this thread is killed forcely
+            # plugin author should refer thread_current_running? method
+            ### TODO: logging or raise or ...
+            ###       raise in tests?
+            raise
+          ensure
+            @_threads.delete(::Thread.current.object_id)
+          end
+        end
+        @_threads[thread.object_id] = thread
+        thread
+      end
+
+      def initialize
+        super
+        @_threads = {}
+      end
+
+      def start
+        super
+      end
+
+      def stop
+        super
+        @_threads.each_pair do |obj_id, thread|
+          thread[:_fluentd_plugin_support_thread_running] = false
+        end
+      end
+
+      def shutdown
+        super
+      end
+
+      def close
+        @_threads.keys.each do |obj_id|
+          thread = @_threads[obj_id]
+          if !thread && thread.join(THREAD_DEFAULT_WAIT_SECONDS)
+            @_threads.delete(obj_id)
+          end
+        end
+
+        super
+      end
+
+      def terminate
+        super
+        @_threads.keys.each do |obj_id|
+          thread = @_threads[obj_id]
+          if thread
+            thread.kill
+            thread.join
+          end
+          @_threads.delete(obj_id)
+        end
+      end
+    end
+  end
+end
diff --git a/lib/fluent/plugin_support/timer.rb b/lib/fluent/plugin_support/timer.rb
new file mode 100644
index 0000000000..e0fffb820b
--- /dev/null
+++ b/lib/fluent/plugin_support/timer.rb
@@ -0,0 +1,71 @@
+#
+# Fluentd
+#
+#    Licensed under the Apache License, Version 2.0 (the "License");
+#    you may not use this file except in compliance with the License.
+#    You may obtain a copy of the License at
+#
+#        http://www.apache.org/licenses/LICENSE-2.0
+#
+#    Unless required by applicable law or agreed to in writing, software
+#    distributed under the License is distributed on an "AS IS" BASIS,
+#    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+#    See the License for the specific language governing permissions and
+#    limitations under the License.
+#
+
+require 'fluent/plugin_support/event_loop'
+
+module Fluent
+  module PluginSupport
+    module Timer
+      include Fluent::PluginSupport::EventLoop
+
+      # interval: integer/float, repeat: true/false
+      def timer_execute(interval:, repeat: true, &block)
+        checker = ->(){ @_timer_running }
+        timer = TimerWatcher.new(interval, repeat, log, checker, &block)
+        event_loop_attach(timer)
+      end
+
+      def initialize
+        super
+        @_timer_running = true
+      end
+
+      def stop
+        super
+      end
+
+      def shutdown
+        @_timer_running = false
+        super
+      end
+
+      def close
+        super
+      end
+
+      def terminate
+        super
+      end
+
+      class TimerWatcher < Coolio::TimerWatcher
+        def initialize(interval, repeat, log, checker, &callback)
+          @callback = callback
+          @log = log
+          @checker = checker
+          super(interval, repeat)
+        end
+
+        def on_timer
+          @callback.call if @checker.call()
+        rescue => e
+          # TODO: raise in tests?
+          @log.error "Something wrong in timer callback", error: e, error_class: e.class
+          @log.error_backtrace
+        end
+      end
+    end
+  end
+end
diff --git a/lib/fluent/plugin_support/udp_server.rb b/lib/fluent/plugin_support/udp_server.rb
new file mode 100644
index 0000000000..c38e4981f1
--- /dev/null
+++ b/lib/fluent/plugin_support/udp_server.rb
@@ -0,0 +1,145 @@
+#
+# Fluentd
+#
+#    Licensed under the Apache License, Version 2.0 (the "License");
+#    you may not use this file except in compliance with the License.
+#    You may obtain a copy of the License at
+#
+#        http://www.apache.org/licenses/LICENSE-2.0
+#
+#    Unless required by applicable law or agreed to in writing, software
+#    distributed under the License is distributed on an "AS IS" BASIS,
+#    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+#    See the License for the specific language governing permissions and
+#    limitations under the License.
+#
+
+require 'fluent/plugin_support/event_loop'
+require 'fluent/plugin_support/socket'
+
+require 'socket'
+require 'ipaddr'
+
+module Fluent
+  module PluginSupport
+    module UDPServer
+      include Fluent::PluginSupport::EventLoop
+      include Fluent::PluginSupport::Socket
+
+      def udp_server_listen(port:, bind: '0.0.0.0', &block)
+        raise "BUG: callback block is not specified for udp_server_listen" unless block_given?
+        port = port.to_i
+
+        socket_listener_add('udp', bind, port)
+
+        bind_sock = if IPAddr.new(IPSocket.getaddress(bind)).ipv4?
+                      UDPSocket.new
+                    else
+                      UDPSocket.new(::Socket::AF_INET6)
+                    end
+        bind_sock.bind(bind, port)
+
+        if self.respond_to?(:detach_multi_process)
+          detach_multi_process do
+            udp_server_listen_impl(bind, port, bind_sock, &block)
+          end
+        elsif self.respond_to?(:detach_process)
+          detach_process do
+            udp_server_listen_impl(bind, port, bind_sock, &block)
+          end
+        else
+          udp_server_listen_impl(bind, port, bind_sock, &block)
+        end
+      end
+
+      def udp_server_read(port:, bind: '0.0.0.0', size_limit: 2048, &block)
+        raise "BUG: callback block is not specified for udp_server_read" unless block_given?
+
+        udp_server_listen(port: port, bind: bind) do |sock|
+          sock.read(size_limit: size_limit, &block)
+        end
+      end
+
+      def initialize
+        super
+        @_udp_server_socks = []
+      end
+
+      def configure(conf)
+        super
+      end
+
+      def stop
+        super
+      end
+
+      def shutdown
+        @_udp_server_socks.each do |s|
+          s.detach if s.attached?
+        end
+
+        super
+      end
+
+      def close
+        @_udp_server_socks.each do |s|
+          s.close unless s.closed?
+        end
+
+        super
+      end
+
+      def terminate
+        @_udp_server_socks = []
+        super
+      end
+
+      def udp_server_listen_impl(bind, port, sock, &block)
+        sock = Handler.new(sock)
+        block.call sock
+        @_udp_server_socks << sock
+        socket_listener_listen('udp', bind, port)
+        event_loop_attach( sock )
+      end
+
+      class Handler < Coolio::IO
+        def initialize(io)
+          super(io)
+
+          @io = io
+
+          ### TODO: address/name, socket option
+          #
+          ###### from tcp server
+          # opt = [1, @timeout.to_i].pack('I!I!')  # { int l_onoff; int l_linger; }
+          # io.setsockopt(Socket::SOL_SOCKET, Socket::SO_LINGER, opt)
+          ####### from in_forward
+          # @usock.fcntl(Fcntl::F_SETFL, Fcntl::O_NONBLOCK)
+        end
+
+        def read(size_limit: 2048, &callback)
+          @size_limit = size_limit
+          @callback = callback
+        end
+
+        def send(host:, port:, data:, flags: 0)
+          @io.send(data, flags, host, port)
+        end
+
+        def on_readable
+          data, addr = @io.recvfrom_nonblock(@size_limit)
+          @callback.call(addr[2], addr[1], data) # host, port, data
+          ## TODO: fix here
+          # rescue => e
+          ####### from in_forward
+          #       rescue Errno::EAGAIN, Errno::EWOULDBLOCK, Errno::EINTR
+          #          return
+
+          # TODO: logging
+          # @log.error "unexpected error", error: e, error_class: e.class
+          # raise
+        end
+      end
+    end
+  end
+end
diff --git a/lib/fluent/process.rb b/lib/fluent/process.rb
index 6130e472a4..28a1161289 100644
--- a/lib/fluent/process.rb
+++ b/lib/fluent/process.rb
@@ -79,9 +79,6 @@ def process_child(ipw, opr, delegate_object)
 
       # override target.emit_stream to write event stream to the pipe
       fwd = new_forwarder(ipw, 0.5)  # TODO interval
-      Engine.define_singleton_method(:emit_stream) do |tag,es|
-        fwd.emit(tag, es)
-      end
 
       # read event stream from the pipe and forward to target.emit
       forward_thread = Thread.new(opr, delegate_object, &method(:output_forward_main))
diff --git a/lib/fluent/registry.rb b/lib/fluent/registry.rb
index e5e1c87188..fa0710b923 100644
--- a/lib/fluent/registry.rb
+++ b/lib/fluent/registry.rb
@@ -14,17 +14,19 @@
 #    limitations under the License.
 #
 
-module Fluent
-  require 'fluent/config/error'
+require 'rubygems'
+require 'fluent/config/error'
 
+module Fluent
   class Registry
     def initialize(kind, search_prefix)
       @kind = kind
       @search_prefix = search_prefix
       @map = {}
+      @paths = []
     end
 
-    attr_reader :kind
+    attr_reader :kind, :paths
 
     def register(type, value)
       type = type.to_sym
@@ -43,11 +45,18 @@ def lookup(type)
       raise ConfigError, "Unknown #{@kind} plugin '#{type}'. Run 'gem search -rd fluentd-plugin' to find plugins"  # TODO error class
     end
 
+    def reverse_lookup(value)
+      @map.each do |k, v|
+        return k if v == value
+      end
+      nil
+    end
+
     def search(type)
       path = "#{@search_prefix}#{type}"
 
       # prefer LOAD_PATH than gems
-      files = $LOAD_PATH.map { |lp|
+      files = ($LOAD_PATH + @paths).map { |lp|
         lpath = File.expand_path(File.join(lp, "#{path}.rb"))
         File.exist?(lpath) ? lpath : nil
       }.compact
diff --git a/lib/fluent/root_agent.rb b/lib/fluent/root_agent.rb
index 16666a4b16..0ed1f9e197 100644
--- a/lib/fluent/root_agent.rb
+++ b/lib/fluent/root_agent.rb
@@ -118,7 +118,7 @@ def shutdown
       @started_inputs.map { |i|
         Thread.new do
           begin
-            log.info "shutting down input", type: Plugin.lookup_name_from_class(i.class), plugin_id: i.plugin_id
+            log.info "shutting down input", type: Plugin.lookup_type_from_class(i.class), plugin_id: i.plugin_id
             i.shutdown
           rescue => e
             log.warn "unexpected error while shutting down input plugin", :plugin => i.class, :plugin_id => i.plugin_id, :error_class => e.class, :error => e
diff --git a/lib/fluent/storage.rb b/lib/fluent/storage.rb
new file mode 100644
index 0000000000..31f1bf45d2
--- /dev/null
+++ b/lib/fluent/storage.rb
@@ -0,0 +1,27 @@
+#
+# Fluentd
+#
+#    Licensed under the Apache License, Version 2.0 (the "License");
+#    you may not use this file except in compliance with the License.
+#    You may obtain a copy of the License at
+#
+#        http://www.apache.org/licenses/LICENSE-2.0
+#
+#    Unless required by applicable law or agreed to in writing, software
+#    distributed under the License is distributed on an "AS IS" BASIS,
+#    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+#    See the License for the specific language governing permissions and
+#    limitations under the License.
+#
+
+require 'fluent/plugin'
+
+# TODO Fluent::Plugin::Storage ?
+
+module Fluent
+  module Storage
+    DEFAULT_TYPE = 'json'
+  end
+end
+
+require 'fluent/storage/base'
diff --git a/lib/fluent/storage/base.rb b/lib/fluent/storage/base.rb
new file mode 100644
index 0000000000..5f7c5d49d9
--- /dev/null
+++ b/lib/fluent/storage/base.rb
@@ -0,0 +1,102 @@
+#
+# Fluentd
+#
+#    Licensed under the Apache License, Version 2.0 (the "License");
+#    you may not use this file except in compliance with the License.
+#    You may obtain a copy of the License at
+#
+#        http://www.apache.org/licenses/LICENSE-2.0
+#
+#    Unless required by applicable law or agreed to in writing, software
+#    distributed under the License is distributed on an "AS IS" BASIS,
+#    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+#    See the License for the specific language governing permissions and
+#    limitations under the License.
+#
+
+require 'fluent/configurable'
+require 'fluent/storage'
+
+require 'monitor'
+
+module Fluent
+  module Storage
+    class Base
+      include Configurable
+
+      attr_accessor :autosave, :save_at_shutdown # to be controlled by plugins
+
+      config_section :storage, required: false, multi: false, param_name: :storage_config do
+        config_param :type, :string, default: Fluent::Storage::DEFAULT_TYPE
+        config_param :save_at_shutdown, :bool, default: true
+        config_param :autosave, :bool, default: true # autosave is done by PluginSupport::Storage in fact
+        config_param :autosave_interval, :time, default: 60
+        config_param :synchronize, :bool, default: true
+      end
+
+      def initialize
+        super
+      end
+
+      def configure(conf)
+        super
+
+        @save_at_shutdown = storage_config.save_at_shutdown
+        @autosave = storage_config.autosave
+
+        @_storage_monitor = Monitor.new if storage_config.synchronize
+      end
+
+      def save_at_shutdown?
+        @save_at_shutdown
+      end
+
+      def autosave?
+        @autosave
+      end
+
+      def autosave_interval
+        storage_config.autosave_interval
+      end
+
+      def synchronize
+        if @_storage_monitor
+          @_storage_monitor.synchronize do
+            yield
+          end
+        else
+          yield
+        end
+      end
+
+      def load
+        # load storage data from any data source, or initialize storage internally
+      end
+
+      def save
+        # save internal data store into data source (to be loaded)
+      end
+
+      def put(key, value)
+        # set of key-valuve store or insert-or-update of RDBMS
+        raise ArgumentError, "key must be a string or symbol" unless key.is_a?(String) || key.is_a?(Symbol)
+        raise NotImplementedError, "Implement this method in child class"
+      end
+
+      def get(key)
+        raise ArgumentError, "key must be a string or symbol" unless key.is_a?(String) || key.is_a?(Symbol)
+        raise NotImplementedError, "Implement this method in child class"
+      end
+
+      def fetch(key, default_value) # just like as Hash#fetch
+        raise ArgumentError, "key must be a string or symbol" unless key.is_a?(String) || key.is_a?(Symbol)
+        raise NotImplementedError, "Implement this method in child class"
+      end
+
+      def delete(key)
+        raise ArgumentError, "key must be a string or symbol" unless key.is_a?(String) || key.is_a?(Symbol)
+        raise NotImplementedError, "Implement this method in child class"
+      end
+    end
+  end
+end
diff --git a/lib/fluent/storage/json.rb b/lib/fluent/storage/json.rb
new file mode 100644
index 0000000000..8bac1194f0
--- /dev/null
+++ b/lib/fluent/storage/json.rb
@@ -0,0 +1,130 @@
+#
+# Fluentd
+#
+#    Licensed under the Apache License, Version 2.0 (the "License");
+#    you may not use this file except in compliance with the License.
+#    You may obtain a copy of the License at
+#
+#        http://www.apache.org/licenses/LICENSE-2.0
+#
+#    Unless required by applicable law or agreed to in writing, software
+#    distributed under the License is distributed on an "AS IS" BASIS,
+#    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+#    See the License for the specific language governing permissions and
+#    limitations under the License.
+#
+
+require 'fluent/storage/base'
+require 'fluent/plugin'
+require 'fluent/env'
+
+require 'json'
+require 'fileutils'
+
+module Fluent
+  module Storage
+    class JSON < Base
+      Fluent::Plugin.register_storage('json', self)
+
+      config_section :storage, required: false, multi: false, param_name: :storage_config do
+        config_param :path, :string
+        config_param :permission, :integer, default: DEFAULT_FILE_PERMISSION
+        config_param :directory_permission, :integer, default: DEFAULT_DIR_PERMISSION
+        config_param :pretty_print, :bool, default: true
+      end
+
+      def initialize
+        super
+        @store = {}
+      end
+
+      def configure(conf)
+        super
+
+        @path = @storage_config.path
+        @perm = @storage_config.permission
+        @dirperm = @storage_config.directory_permission
+        @tmp_path = @path + '.tmp'
+        @pretty_print = @storage_config.pretty_print
+      end
+
+      def load
+        unless FileTest.exist?(@path)
+          @store = {}
+          return
+        end
+
+        unless FileTest.file?(@path)
+          raise LoadError, "specified json storage file path is not a normal file: '#{@path}'"
+        end
+        unless FileTest.readable?(@path)
+          raise LoadError, "specified json storage path is not readable/writable: '#{@path}'"
+        end
+
+        begin
+          synchronize do
+            json_string = open(@path, 'r:utf-8') { |io| io.read }
+            @store = ::JSON.parse(json_string, symbolize_names: true)
+          end
+        rescue IOError => e
+          raise LoadError, "IOError: " + e.message
+        rescue SystemCallError => e
+          raise LoadError, "SystemCallError(#{e.class}): " + e.message
+        rescue ::JSON::ParserError => e
+          raise LoadError, "ParserError: " + e.message
+        end
+
+        self
+      end
+
+      def save
+        begin
+          synchronize do
+            json_string = if @pretty_print
+                            ::JSON.pretty_generate(@store)
+                          else
+                            ::JSON.generate(@store)
+                          end
+            FileUtils.mkdir_p(File.dirname(@tmp_path), mode: @dirperm)
+            open(@tmp_path, 'w:utf-8', @perm) do |io|
+              io.write json_string
+            end
+            File.rename(@tmp_path, @path)
+          end
+        rescue IOError => e
+          raise SaveError, "IOError: " + e.message
+        rescue SystemCallError => e
+          raise SaveError, "SystemCallError(#{e.class}): " + e.message
+        rescue ::JSON::GeneratorError => e
+          raise SaveError, "GeneratorError: " + e.message
+        end
+
+        self
+      end
+
+      def put(key, value)
+        synchronize do
+          @store[key.to_sym] = value
+        end
+      end
+
+      def get(key)
+        synchronize do
+          @store[key.to_sym]
+        end
+      end
+
+      def fetch(key, default_value)
+        synchronize do
+          @store.fetch(key.to_sym, default_value)
+        end
+      end
+
+      def delete(key)
+        synchronize do
+          @store.delete(key.to_sym)
+        end
+      end
+    end
+  end
+end
diff --git a/lib/fluent/storage/memory.rb b/lib/fluent/storage/memory.rb
new file mode 100644
index 0000000000..c292c19ce7
--- /dev/null
+++ b/lib/fluent/storage/memory.rb
@@ -0,0 +1,73 @@
+#
+# Fluentd
+#
+#    Licensed under the Apache License, Version 2.0 (the "License");
+#    you may not use this file except in compliance with the License.
+#    You may obtain a copy of the License at
+#
+#        http://www.apache.org/licenses/LICENSE-2.0
+#
+#    Unless required by applicable law or agreed to in writing, software
+#    distributed under the License is distributed on an "AS IS" BASIS,
+#    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+#    See the License for the specific language governing permissions and
+#    limitations under the License.
+#
+
+require 'fluent/storage/base'
+require 'fluent/plugin'
+
+module Fluent
+  module Storage
+    class Memory < Base
+      # This is on-memory Hash object itself, to provide same API as plugin storage
+      Fluent::Plugin.register_storage('memory', self)
+
+      config_section :storage, required: false, multi: false, param_name: :storage_config do
+        config_set_default :autosave, false
+        config_set_default :save_at_shutdown, false
+      end
+
+      def initialize
+        super
+        @store = {}
+      end
+
+      def configure(conf)
+        super
+      end
+
+      def load
+        self
+      end
+
+      def save
+        self
+      end
+
+      def put(key, value)
+        synchronize do
+          @store[key.to_sym] = value
+        end
+      end
+
+      def get(key)
+        synchronize do
+          @store[key.to_sym]
+        end
+      end
+
+      def fetch(key, default_value)
+        synchronize do
+          @store.fetch(key.to_sym, default_value)
+        end
+      end
+
+      def delete(key)
+        synchronize do
+          @store.delete(key.to_sym)
+        end
+      end
+    end
+  end
+end
diff --git a/lib/fluent/supervisor.rb b/lib/fluent/supervisor.rb
index d3f88c58c7..f05e3e90e6 100644
--- a/lib/fluent/supervisor.rb
+++ b/lib/fluent/supervisor.rb
@@ -15,6 +15,7 @@
 #
 
 require 'fluent/load'
+require 'fluent/system_config'
 require 'etc'
 if Fluent.windows?
   require 'windows/library'
@@ -100,6 +101,7 @@ def self.default_options
         :suppress_interval => 0,
         :suppress_repeated_stacktrace => true,
         :without_source => false,
+        :plugin_storage_path => nil,
         :use_v1_config => true,
         :supervise => true,
         :signame => nil,
@@ -128,6 +130,7 @@ def initialize(opt)
       @suppress_config_dump = opt[:suppress_config_dump]
       @without_source = opt[:without_source]
       @signame = opt[:signame]
+      @plugin_storage_path = opt[:plugin_storage_path]
 
       if Fluent.windows?
         ruby_path = "\0" * 256
@@ -146,7 +149,8 @@ def start
       @log.init
       show_plugin_config if @show_plugin_config
       read_config
-      apply_system_config
+      @system_config = SystemConfig.create(@conf) # @conf is set in read_config
+      @system_config.apply(self)
 
       dry_run if @dry_run
       start_daemonize if @daemonize
@@ -518,40 +522,6 @@ def read_config
       @conf = Fluent::Config.parse(@config_data, @config_fname, @config_basedir, @use_v1_config)
     end
 
-    class SystemConfig
-      include Configurable
-
-      config_param :log_level, :default => nil do |level|
-        Log.str_to_level(level)
-      end
-      config_param :suppress_repeated_stacktrace, :bool, :default => nil
-      config_param :emit_error_log_interval, :time, :default => nil
-      config_param :suppress_config_dump, :bool, :default => nil
-      config_param :without_source, :bool, :default => nil
-      config_param :rpc_endpoint, :string, :default => nil
-      config_param :enable_get_dump, :bool, :default => nil
-      config_param :process_name, :default => nil
-
-      def initialize(conf)
-        super()
-        configure(conf)
-      end
-
-      def apply(supervisor)
-        system = self
-        supervisor.instance_eval {
-          @log.level = @log_level = system.log_level unless system.log_level.nil?
-          @suppress_interval = system.emit_error_log_interval unless system.emit_error_log_interval.nil?
-          @suppress_config_dump = system.suppress_config_dump unless system.suppress_config_dump.nil?
-          @suppress_repeated_stacktrace = system.suppress_repeated_stacktrace unless system.suppress_repeated_stacktrace.nil?
-          @without_source = system.without_source unless system.without_source.nil?
-          @rpc_endpoint = system.rpc_endpoint unless system.rpc_endpoint.nil?
-          @enable_get_dump = system.enable_get_dump unless system.enable_get_dump.nil?
-          @process_name = system.process_name unless system.process_name.nil?
-        }
-      end
-    end
-
     # TODO: this method should be moved to SystemConfig class method
     def apply_system_config
       systems = @conf.elements.select { |e|
@@ -585,7 +555,7 @@ def change_privilege
     end
 
     def init_engine
-      init_opts = {:suppress_interval => @suppress_interval, :suppress_config_dump => @suppress_config_dump, :without_source => @without_source}
+      init_opts = {:suppress_interval => @suppress_interval, :suppress_config_dump => @suppress_config_dump, :without_source => @without_source, :plugin_storage_path => @plugin_storage_path, :system_config => @system_config}
       Fluent::Engine.init(init_opts)
 
       @libs.each {|lib|
@@ -595,7 +565,7 @@ def init_engine
       @plugin_dirs.each {|dir|
         if Dir.exist?(dir)
           dir = File.expand_path(dir)
-          Fluent::Engine.load_plugin_dir(dir)
+          Fluent::Engine.add_plugin_dir(dir)
         end
       }
     end
diff --git a/lib/fluent/system_config.rb b/lib/fluent/system_config.rb
new file mode 100644
index 0000000000..0c45de9b44
--- /dev/null
+++ b/lib/fluent/system_config.rb
@@ -0,0 +1,95 @@
+#
+# Fluent
+#
+#    Licensed under the Apache License, Version 2.0 (the "License");
+#    you may not use this file except in compliance with the License.
+#    You may obtain a copy of the License at
+#
+#        http://www.apache.org/licenses/LICENSE-2.0
+#
+#    Unless required by applicable law or agreed to in writing, software
+#    distributed under the License is distributed on an "AS IS" BASIS,
+#    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+#    See the License for the specific language governing permissions and
+#    limitations under the License.
+#
+
+require 'fluent/configurable'
+
+module Fluent
+  module SystemConfigMixin
+    def system_config
+      @_system_config || Fluent::Engine.system_config
+    end
+
+    def system_config_override(opts={})
+      unless @_system_config
+        @_system_config = Fluent::Engine.system_config.dup
+      end
+      opts.each_pair do |key, value|
+        @_system_config.send(:"#{key.to_s}=", value)
+      end
+    end
+  end
+
+  class SystemConfig
+    include Configurable
+
+    config_param :log_level, default: nil do |level|
+      Log.str_to_level(level)
+    end
+    config_param :suppress_repeated_stacktrace, :bool, default: nil
+    config_param :emit_error_log_interval, :time, default: nil
+    config_param :suppress_config_dump, :bool, default: nil
+    config_param :without_source, :bool, default: nil
+    config_param :plugin_storage_path, :string, default: nil
+    config_param :rpc_endpoint, :string, default: nil
+    config_param :enable_get_dump, :bool, default: nil
+    config_param :process_name, default: nil
+
+    def self.create(conf)
+      systems = conf.elements.select { |e|
+        e.name == 'system'
+      }
+      return SystemConfig.new({}) if systems.empty?
+      raise Fluent::ConfigError, "<system> is duplicated. <system> should be only one" if systems.size > 1
+
+      SystemConfig.new(systems.first)
+    end
+
+    def initialize(conf)
+      super()
+      configure(conf)
+    end
+
+    def dup
+      s = SystemConfig.new({})
+      s.log_level = @log_level
+      s.suppress_repeated_stacktrace = @suppress_repeated_stacktrace
+      s.emit_error_log_interval = @emit_error_log_interval
+      s.suppress_config_dump = @suppress_config_dump
+      s.without_source = @without_source
+      s.rpc_endpoint = @rpc_endpoint
+      s.enable_get_dump = @enable_get_dump
+      s.process_name = @process_name
+      s.plugin_storage_path = @plugin_storage_path
+
+      s
+    end
+
+    def apply(supervisor)
+      system = self
+      supervisor.instance_eval {
+        @log.level = @log_level = system.log_level unless system.log_level.nil?
+        @suppress_interval = system.emit_error_log_interval unless system.emit_error_log_interval.nil?
+        @suppress_config_dump = system.suppress_config_dump unless system.suppress_config_dump.nil?
+        @suppress_repeated_stacktrace = system.suppress_repeated_stacktrace unless system.suppress_repeated_stacktrace.nil?
+        @without_source = system.without_source unless system.without_source.nil?
+        @rpc_endpoint = system.rpc_endpoint unless system.rpc_endpoint.nil?
+        @enable_get_dump = system.enable_get_dump unless system.enable_get_dump.nil?
+        @process_name = system.process_name unless system.process_name.nil?
+        @plugin_storage_path = system.plugin_storage_path unless system.plugin_storage_path.nil?
+      }
+    end
+  end
+end
diff --git a/lib/fluent/test.rb b/lib/fluent/test.rb
index f552f7a20d..2d1f28c129 100644
--- a/lib/fluent/test.rb
+++ b/lib/fluent/test.rb
@@ -15,6 +15,11 @@
 #
 
 require 'test/unit'
+
+# TODO: remove this line after `require 'fluent/load'` deleted
+#       all test (and implementation) files should require its dependency by itself
+$log = Fluent::Log.new(StringIO.new, Fluent::Log::LEVEL_WARN)
+
 require 'fluent/load'
 require 'fluent/test/base'
 require 'fluent/test/input_test'
@@ -23,4 +28,4 @@
 require 'fluent/test/parser_test'
 require 'fluent/test/formatter_test'
 
-$log ||= Fluent::Log.new(Fluent::Test::DummyLogDevice.new)
+require 'fluent/test/driver/input'
diff --git a/lib/fluent/test/base.rb b/lib/fluent/test/base.rb
index a3f9b77de0..b22c042c96 100644
--- a/lib/fluent/test/base.rb
+++ b/lib/fluent/test/base.rb
@@ -37,6 +37,7 @@ def assert_equal_event_time(a, b)
       nil
     end
 
+    # obsolete for v0.14
     class TestDriver
       include ::Test::Unit::Assertions
 
diff --git a/lib/fluent/test/driver.rb b/lib/fluent/test/driver.rb
new file mode 100644
index 0000000000..f24961d230
--- /dev/null
+++ b/lib/fluent/test/driver.rb
@@ -0,0 +1,22 @@
+#
+# Fluentd
+#
+#    Licensed under the Apache License, Version 2.0 (the "License");
+#    you may not use this file except in compliance with the License.
+#    You may obtain a copy of the License at
+#
+#        http://www.apache.org/licenses/LICENSE-2.0
+#
+#    Unless required by applicable law or agreed to in writing, software
+#    distributed under the License is distributed on an "AS IS" BASIS,
+#    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+#    See the License for the specific language governing permissions and
+#    limitations under the License.
+#
+
+module Fluent
+  module Test
+    module Driver
+    end
+  end
+end
diff --git a/lib/fluent/test/driver/base.rb b/lib/fluent/test/driver/base.rb
new file mode 100644
index 0000000000..47ad394623
--- /dev/null
+++ b/lib/fluent/test/driver/base.rb
@@ -0,0 +1,118 @@
+#
+# Fluentd
+#
+#    Licensed under the Apache License, Version 2.0 (the "License");
+#    you may not use this file except in compliance with the License.
+#    You may obtain a copy of the License at
+#
+#        http://www.apache.org/licenses/LICENSE-2.0
+#
+#    Unless required by applicable law or agreed to in writing, software
+#    distributed under the License is distributed on an "AS IS" BASIS,
+#    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+#    See the License for the specific language governing permissions and
+#    limitations under the License.
+#
+
+require 'test/unit'
+
+module Fluent
+  module Test
+    module Driver
+      class Base
+        include ::Test::Unit::Assertions
+
+        def initialize(klass, opts={}, &block)
+          if klass.is_a?(Class)
+            if block
+              # Create new class for test w/ overwritten methods
+              #   klass.dup is worse because its ancestors does NOT include original class name
+              klass = Class.new(klass)
+              klass.module_eval(&block)
+            end
+            @instance = klass.new
+          else
+            @instance = klass
+          end
+          if opts
+            @instance.system_config_override(opts)
+          end
+          @instance.router = Engine.root_agent.event_router
+          @instance.log = TestLogger.new
+
+          @config = Config.new
+        end
+
+        attr_reader :instance, :config
+
+        def configure(str, use_v1=true) # v1 syntax default
+          if str.is_a?(Fluent::Config::Element)
+            @config = str
+          else
+            @config = Config.parse(str, "(test)", "(test_dir)", use_v1)
+          end
+          if label_name = @config['@label']
+            Engine.root_agent.add_label(label_name)
+          end
+          @instance.configure(@config)
+          self
+        end
+
+        def run(&block)
+          @instance.start
+          if @instance.respond_to?(:_listener_states)
+            until @instance._listener_states.values.all?
+              sleep 0.01
+            end
+          end
+          if @instance.respond_to?(:event_loop_running?)
+            until @instance.event_loop_running?
+              sleep 0.01
+            end
+          end
+          if @instance.respond_to?(:_threads)
+            until @instance._threads.values.all?(&:alive?)
+              sleep 0.01
+            end
+          end
+          begin
+            yield
+          ensure
+            @instance.stop
+            @instance.shutdown
+            @instance.close
+            @instance.terminate
+          end
+        end
+
+        def stop?
+          # Should stop running if post conditions are not registered.
+          return true unless @run_post_conditions
+
+          # Should stop running if all of the post conditions are true.
+          return true if @run_post_conditions.all? {|proc| proc.call }
+
+          # Should stop running if any of the breaking conditions is true.
+          # In this case, some post conditions may be not true.
+          return true if @run_breaking_conditions && @run_breaking_conditions.any? {|proc| proc.call }
+
+          false
+        end
+
+        def end_if(&block)
+          if block
+            @run_post_conditions ||= []
+            @run_post_conditions << block
+          end
+        end
+
+        def break_if(&block)
+          if block
+            @run_breaking_conditions ||= []
+            @run_breaking_conditions << block
+          end
+        end
+      end
+    end
+  end
+end
diff --git a/lib/fluent/test/driver/event_router.rb b/lib/fluent/test/driver/event_router.rb
new file mode 100644
index 0000000000..ab57053e6c
--- /dev/null
+++ b/lib/fluent/test/driver/event_router.rb
@@ -0,0 +1,44 @@
+#
+# Fluentd
+#
+#    Licensed under the Apache License, Version 2.0 (the "License");
+#    you may not use this file except in compliance with the License.
+#    You may obtain a copy of the License at
+#
+#        http://www.apache.org/licenses/LICENSE-2.0
+#
+#    Unless required by applicable law or agreed to in writing, software
+#    distributed under the License is distributed on an "AS IS" BASIS,
+#    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+#    See the License for the specific language governing permissions and
+#    limitations under the License.
+#
+
+module Fluent
+  module Test
+    module Driver
+      class EventRouter
+        def initialize(&block)
+          @block = block
+          # TODO: emit_error_handler -> logger
+        end
+
+        def emit(tag, time, record)
+          unless record.nil?
+            emit_stream(tag, OneEventStream.new(time, record))
+          end
+        end
+
+        def emit_array(tag, array)
+          emit_stream(tag, ArrayEventStream.new(array))
+        end
+
+        def emit_stream(tag, es)
+          @block.call(tag, es)
+        rescue => e
+          @emit_error_handler.handle_emits_error(tag, es, e)
+        end
+      end
+    end
+  end
+end
diff --git a/lib/fluent/test/driver/input.rb b/lib/fluent/test/driver/input.rb
new file mode 100644
index 0000000000..fa290dd904
--- /dev/null
+++ b/lib/fluent/test/driver/input.rb
@@ -0,0 +1,114 @@
+#
+# Fluentd
+#
+#    Licensed under the Apache License, Version 2.0 (the "License");
+#    you may not use this file except in compliance with the License.
+#    You may obtain a copy of the License at
+#
+#        http://www.apache.org/licenses/LICENSE-2.0
+#
+#    Unless required by applicable law or agreed to in writing, software
+#    distributed under the License is distributed on an "AS IS" BASIS,
+#    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+#    See the License for the specific language governing permissions and
+#    limitations under the License.
+#
+
+require 'fluent/test/driver/base'
+require 'fluent/test/driver/event_router'
+
+module Fluent
+  # TODO: Chekc What is this for?
+  class FileBuffer < BasicBuffer
+    def self.clear_buffer_paths
+      @@buffer_paths = {}
+    end
+  end
+
+  module Test
+    module Driver
+      class Input < Base
+        attr_accessor :run_timeout, :expected_emits_length
+        attr_reader :emit_streams
+
+        def initialize(klass, opts={}, &block)
+          FileBuffer.clear_buffer_paths
+
+          super
+
+          @emit_streams = []
+          @run_timeout = 60
+          @expected_emits_length = nil
+        end
+
+        def emits
+          all = []
+          @emit_streams.each do |tag,events|
+            events.each do |time,record|
+              all << [tag, time, record]
+            end
+          end
+          all
+        end
+
+        def events
+          emits.map{|tag, time, record| [time, record] }
+        end
+
+        def records
+          emits.map{|tag, time, record| record }
+        end
+
+        def run(&block)
+          m = method(:emit_stream)
+          r = Fluent::Test::Driver::EventRouter.new do |tag, es|
+            m.call(tag, es)
+          end
+          instance.router = r
+          super do
+            block.call if block
+
+            if @expected_emits_length || @run_post_conditions
+              # counters for emits and emit_streams
+              emitted_count = 0
+              emit_times_count = 0
+
+              # Events of expected length will be emitted at the end.
+              if @expected_emits_length
+                end_if do
+                  emitted_count >= @expected_emits_length
+                end
+              end
+
+              # Set runnning timeout to avoid infinite loop caused by some errors.
+              started_at = Time.now
+              break_if do
+                Time.now >= started_at + @run_timeout
+              end
+
+              until stop?
+                if emit_times_count == @emit_streams.length
+                  sleep 0.01
+                  next
+                end
+                while emit_times_count < @emit_streams.length
+                  tag, events = @emit_streams[emit_times_count]
+                  events.each do |e| # EventStream doesn't have #size/#length
+                    emitted_count += 1
+                  end
+                  emit_times_count += 1
+                end
+              end
+            end
+          end
+          self
+        end
+
+        private
+        def emit_stream(tag, es)
+          @emit_streams << [tag, es]
+        end
+      end
+    end
+  end
+end
diff --git a/lib/fluent/test/input_test.rb b/lib/fluent/test/input_test.rb
index dbd9c06b3d..27715e573b 100644
--- a/lib/fluent/test/input_test.rb
+++ b/lib/fluent/test/input_test.rb
@@ -14,6 +14,8 @@
 #    limitations under the License.
 #
 
+require 'fluent/buffer'
+
 module Fluent
   class FileBuffer < BasicBuffer
     def self.clear_buffer_paths
diff --git a/test/config/test_configurable.rb b/test/config/test_configurable.rb
index 14d509216a..0d31fb4025 100644
--- a/test/config/test_configurable.rb
+++ b/test/config/test_configurable.rb
@@ -573,7 +573,7 @@ def e(name, arg = '', attrs = {}, elements = [])
           Fluent::Config::Element.new(name, arg, attrs_str_keys, elements)
         end
 
-        test 'subclass configuration spec can overwrite superclass specs' do
+        test 'adds only config_param definitions into configuration without overwriting existing configuration elements' do
           # conf0 = e('ROOT', '', {}, [])
 
           conf1 = e('ROOT', '', {
diff --git a/test/config/test_section.rb b/test/config/test_section.rb
index df1bb3ffc6..9ef088e3d6 100644
--- a/test/config/test_section.rb
+++ b/test/config/test_section.rb
@@ -43,6 +43,22 @@ class TestSection < ::Test::Unit::TestCase
 
             assert_raise(NoMethodError) { s1.dup }
           end
+
+          test 'creates object which contains specified hash object itself, including fields with at prefix' do
+            hash = {
+              name: 'tagomoris',
+              age: 34,
+              send: 'email',
+              class: 'normal',
+              keys: 5,
+            }
+            hash['@id'.to_sym] = 'myid'
+
+            s1 = Fluent::Config::Section.new(hash)
+            assert_equal('myid', s1['@id'])
+            assert_equal('myid', s1['@id'.to_sym])
+            assert_equal('myid', s1.__send__('@id'.to_sym))
+          end
         end
 
         sub_test_case '#object_id' do
diff --git a/test/config/test_system_config.rb b/test/config/test_system_config.rb
index 0775415d67..e4cfb13f01 100644
--- a/test/config/test_system_config.rb
+++ b/test/config/test_system_config.rb
@@ -2,7 +2,7 @@
 require 'fluent/configurable'
 require 'fluent/config/element'
 require 'fluent/config/section'
-require 'fluent/supervisor'
+require 'fluent/system_config'
 
 module Fluent::Config
   class FakeLoggerInitializer
@@ -36,7 +36,7 @@ def parse_text(text)
         </system>
       EOS
       s = FakeSupervisor.new
-      sc = Fluent::Supervisor::SystemConfig.new(conf)
+      sc = Fluent::SystemConfig.new(conf)
       sc.apply(s)
       assert_nil(sc.log_level)
       assert_nil(sc.suppress_repeated_stacktrace)
@@ -63,7 +63,7 @@ def parse_text(text)
           </system>
         EOS
         s = FakeSupervisor.new
-        sc = Fluent::Supervisor::SystemConfig.new(conf)
+        sc = Fluent::SystemConfig.new(conf)
         sc.apply(s)
         assert_not_nil(sc.instance_variable_get("@#{k}"))
         key = (k == 'emit_error_log_interval' ? 'suppress_interval' : k)
@@ -74,7 +74,7 @@ def parse_text(text)
     {'foo' => 'bar', 'hoge' => 'fuga'}.each { |k, v|
       test "should not affect settable parameters with unknown #{k} parameter" do
         s = FakeSupervisor.new
-        sc = Fluent::Supervisor::SystemConfig.new({k => v})
+        sc = Fluent::SystemConfig.new({k => v})
         sc.apply(s)
         assert_nil(s.instance_variable_get(:@log_level))
         assert_nil(s.instance_variable_get(:@suppress_repeated_stacktrace))
@@ -91,7 +91,7 @@ def parse_text(text)
         </system>
       EOS
       s = FakeSupervisor.new
-      sc = Fluent::Supervisor::SystemConfig.new(conf)
+      sc = Fluent::SystemConfig.new(conf)
       sc.apply(s)
       assert_equal(Fluent::Log::LEVEL_WARN, s.instance_variable_get("@log").level)
     end
diff --git a/test/helper.rb b/test/helper.rb
index 86acd6953b..02f9a3c4e1 100644
--- a/test/helper.rb
+++ b/test/helper.rb
@@ -42,16 +42,27 @@ def to_masked_element
 require 'fluent/log'
 require 'fluent/test'
 
+$log = Fluent::Log.new(Fluent::Test::DummyLogDevice.new, Fluent::Log::LEVEL_WARN)
+
 unless defined?(Test::Unit::AssertionFailedError)
   class Test::Unit::AssertionFailedError < StandardError
   end
 end
 
-def unused_port
-  s = TCPServer.open(0)
-  port = s.addr[1]
-  s.close
-  port
+def unused_port(num=1)
+  ports = []
+  sockets = []
+  num.times do
+    s = TCPServer.open(0)
+    sockets << s
+    ports << s.addr[1]
+  end
+  sockets.each{|s| s.close }
+  if num == 1
+    ports.first
+  else
+    ports
+  end
 end
 
 def ipv6_enabled?
@@ -64,5 +75,3 @@ def ipv6_enabled?
     false
   end
 end
-
-$log = Fluent::Log.new(Fluent::Test::DummyLogDevice.new, Fluent::Log::LEVEL_WARN)
diff --git a/test/plugin/test_in_debug_agent.rb b/test/plugin/test_in_debug_agent.rb
index 4ca94eb682..3de87e0461 100644
--- a/test/plugin/test_in_debug_agent.rb
+++ b/test/plugin/test_in_debug_agent.rb
@@ -1,5 +1,6 @@
 require_relative '../helper'
 require 'fileutils'
+require 'fluent/plugin/in_debug_agent'
 
 class DebugAgentInputTest < Test::Unit::TestCase
   def setup
diff --git a/test/plugin/test_in_dummy.rb b/test/plugin/test_in_dummy.rb
index d2bf159bc0..31ee031a25 100644
--- a/test/plugin/test_in_dummy.rb
+++ b/test/plugin/test_in_dummy.rb
@@ -1,13 +1,15 @@
 require_relative '../helper'
 require 'fluent/test'
+require 'fluent/plugin/in_dummy'
+require 'fileutils'
 
 class DummyTest < Test::Unit::TestCase
   def setup
     Fluent::Test.setup
   end
 
-  def create_driver(conf)
-    Fluent::Test::InputTestDriver.new(Fluent::DummyInput).configure(conf)
+  def create_driver(conf, system_opts={})
+    Fluent::Test::Driver::Input.new(Fluent::Plugin::DummyInput, system_opts).configure(conf)
   end
 
   sub_test_case 'configure' do
@@ -70,9 +72,9 @@ def create_driver(conf)
 
     test 'simple' do
       d = create_driver(config)
-      d.run {
-        # d.run sleeps 0.5 sec
-      }
+      d.expected_emits_length = 5
+      d.run
+
       emits = d.emits
       emits.each do |tag, time, record|
         assert_equal("dummy", tag)
@@ -83,9 +85,9 @@ def create_driver(conf)
 
     test 'with auto_increment_key' do
       d = create_driver(config + %[auto_increment_key id])
-      d.run {
-        # d.run sleeps 0.5 sec
-      }
+      d.expected_emits_length = 5
+      d.run
+
       emits = d.emits
       emits.each_with_index do |(tag, time, record), i|
         assert_equal("dummy", tag)
@@ -93,4 +95,81 @@ def create_driver(conf)
       end
     end
   end
+
+  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
+    config1 = %[
+      @id test-01
+      tag dummy
+      rate 10
+      dummy [{"x": 1, "y": "1"}, {"x": 2, "y": "2"}, {"x": 3, "y": "3"}]
+      auto_increment_key id
+    ]
+    test "value of auto increment key is not suspended after stop-and-start" do
+      assert !File.exist?(File.join(TEST_PLUGIN_STORAGE_PATH, 'json', 'test-01.json'))
+
+      d1 = create_driver(config1, plugin_storage_path: TEST_PLUGIN_STORAGE_PATH)
+      d1.expected_emits_length = 4
+      d1.run
+
+      first_id1 = d1.emits.first[2]['id']
+      assert_equal 0, first_id1
+
+      last_id1 = d1.emits.last[2]['id']
+      assert { last_id1 > 0 }
+
+      assert !File.exist?(File.join(TEST_PLUGIN_STORAGE_PATH, 'json', 'test-01.json'))
+
+      d2 = create_driver(config1, plugin_storage_path: TEST_PLUGIN_STORAGE_PATH)
+      d2.expected_emits_length = 4
+      d2.run
+
+      first_id2 = d2.emits.first[2]['id']
+      assert_equal 0, first_id2
+
+      assert !File.exist?(File.join(TEST_PLUGIN_STORAGE_PATH, 'json', 'test-01.json'))
+    end
+  end
+
+  sub_test_case "suspend internal counters if suspend is true" do
+    setup do
+      FileUtils.rm_rf(TEST_PLUGIN_STORAGE_PATH)
+    end
+
+    config2 = %[
+      @id test-02
+      tag dummy
+      rate 2
+      dummy [{"x": 1, "y": "1"}, {"x": 2, "y": "2"}, {"x": 3, "y": "3"}]
+      auto_increment_key id
+      suspend true
+    ]
+    test "value of auto increment key is suspended after stop-and-start" do
+      assert !File.exist?(File.join(TEST_PLUGIN_STORAGE_PATH, 'json', 'test-02.json'))
+
+      d1 = create_driver(config2, plugin_storage_path: TEST_PLUGIN_STORAGE_PATH)
+
+      d1.expected_emits_length = 4
+      d1.run
+
+      first_id1 = d1.emits.first[2]['id']
+      assert_equal 0, first_id1
+
+      last_id1 = d1.emits.last[2]['id']
+      assert { last_id1 > 0 }
+
+      assert File.exist?(File.join(TEST_PLUGIN_STORAGE_PATH, 'json', 'test-02.json'))
+
+      d2 = create_driver(config2, plugin_storage_path: TEST_PLUGIN_STORAGE_PATH)
+      d2.expected_emits_length = 4
+      d2.run
+
+      first_id2 = d2.emits.first[2]['id']
+      assert_equal last_id1 + 1, first_id2
+
+      assert File.exist?(File.join(TEST_PLUGIN_STORAGE_PATH, 'json', 'test-02.json'))
+    end
+  end
 end
diff --git a/test/plugin/test_in_exec.rb b/test/plugin/test_in_exec.rb
index 34c7abcea1..96e672c03b 100644
--- a/test/plugin/test_in_exec.rb
+++ b/test/plugin/test_in_exec.rb
@@ -1,59 +1,53 @@
 require_relative '../helper'
 require 'fluent/test'
 require 'net/http'
+require 'fluent/plugin/in_exec'
 
 class ExecInputTest < Test::Unit::TestCase
   def setup
     Fluent::Test.setup
-    @test_time = Fluent::EventTime.parse("2011-01-02 13:14:15")
-    @script = File.expand_path(File.join(File.dirname(__FILE__), '..', 'scripts', 'exec_script.rb'))
   end
 
-  def create_driver(conf = tsv_config)
-    Fluent::Test::InputTestDriver.new(Fluent::ExecInput).configure(conf)
+  def create_driver(conf=TSV_CONFIG)
+    Fluent::Test::Driver::Input.new(Fluent::Plugin::ExecInput).configure(conf)
   end
 
-  def tsv_config
-    %[
-      command ruby #{@script} "2011-01-02 13:14:15" 0
+  TEST_TIME = Time.parse("2011-01-02 13:14:15").to_i
+  SCRIPT = File.expand_path(File.join(File.dirname(__FILE__), '..', 'scripts', 'exec_script.rb'))
+
+  TSV_CONFIG = %[
+      command ruby #{SCRIPT} #{TEST_TIME} 0
       keys time,tag,k1
       time_key time
       tag_key tag
       time_format %Y-%m-%d %H:%M:%S
       run_interval 1s
-    ]
-  end
+  ]
 
-  def json_config
-    %[
-      command ruby #{@script} #{@test_time} 1
+  JSON_CONFIG = %[
+      command ruby #{SCRIPT} #{TEST_TIME} 1
       format json
       tag_key tag
       time_key time
       run_interval 1s
-    ]
-  end
+  ]
 
-  def msgpack_config
-    %[
-      command ruby #{@script} #{@test_time} 2
+  MSGPACK_CONFIG = %[
+      command ruby #{SCRIPT} #{TEST_TIME} 2
       format msgpack
       tag_key tagger
       time_key datetime
       run_interval 1s
-    ]
-  end
+  ]
 
-  def regexp_config
-    %[
-      command ruby #{@script} "2011-01-02 13:14:15" 3
+  REGEXP_CONFIG = %[
+      command ruby #{SCRIPT} #{TEST_TIME} 3
       format /(?<time>[^\\\]]*) (?<message>[^ ]*)/
       tag regex_tag
       run_interval 1s
-    ]
-  end
+  ]
 
-  def test_configure
+  test "configure with basic configuration" do
     d = create_driver
     assert_equal 'tsv', d.instance.format
     assert_equal ["time","tag","k1"], d.instance.keys
@@ -62,75 +56,39 @@ def test_configure
     assert_equal "%Y-%m-%d %H:%M:%S", d.instance.time_format
   end
 
-  def test_configure_with_json
-    d = create_driver json_config
-    assert_equal 'json', d.instance.format
+  test "configure with json configuration" do
+    d = create_driver JSON_CONFIG
+    assert_equal :json, d.instance.format
     assert_equal [], d.instance.keys
   end
 
-  def test_configure_with_msgpack
-    d = create_driver msgpack_config
-    assert_equal 'msgpack', d.instance.format
+  test "configure with msgpack configuration" do
+    d = create_driver MSGPACK_CONFIG
+    assert_equal :msgpack, d.instance.format
     assert_equal [], d.instance.keys
   end
 
-  def test_configure_with_regexp
-    d = create_driver regexp_config
+  test "configure with regexp configuration" do
+    d = create_driver REGEXP_CONFIG
     assert_equal '/(?<time>[^\]]*) (?<message>[^ ]*)/', d.instance.format
     assert_equal 'regex_tag', d.instance.tag
   end
 
-  # TODO: Merge following tests into one case with parameters
-
-  def test_emit
-    d = create_driver
-
-    d.run do
-      sleep 2
-    end
-
-    emits = d.emits
-    assert_equal true, emits.length > 0
-    assert_equal ["tag1", @test_time, {"k1"=>"ok"}], emits[0]
-    assert_equal_event_time(@test_time, emits[0][1])
-  end
-
-  def test_emit_json
-    d = create_driver json_config
-
-    d.run do
-      sleep 2
-    end
-
-    emits = d.emits
-    assert_equal true, emits.length > 0
-    assert_equal ["tag1", @test_time, {"k1"=>"ok"}], emits[0]
-    assert_equal_event_time(@test_time, emits[0][1])
-  end
-
-  def test_emit_msgpack
-    d = create_driver msgpack_config
-
-    d.run do
-      sleep 2
-    end
-
-    emits = d.emits
-    assert_equal true, emits.length > 0
-    assert_equal ["tag1", @test_time, {"k1"=>"ok"}], emits[0]
-    assert_equal_event_time(@test_time, emits[0][1])
-  end
-
-  def test_emit_regexp
-    d = create_driver regexp_config
-
-    d.run do
-      sleep 2
-    end
+  data(
+    'tsv' => TSV_CONFIG,
+    'json' => JSON_CONFIG,
+    'msgpack' => MSGPACK_CONFIG,
+    'regexp' => REGEXP_CONFIG,
+  )
+  test "this plugin emits record from executed command output" do |data|
+    d = create_driver data
+    d.run_timeout = 2
+    d.expected_emits_length = 1
+    d.run
 
     emits = d.emits
-    assert_equal true, emits.length > 0
-    assert_equal ["regex_tag", @test_time, {"message"=>"hello"}], emits[0]
-    assert_equal_event_time(@test_time, emits[0][1])
+    assert emits.length > 0
+    assert_equal ["tag1", TEST_TIME, {"k1"=>"ok"}], emits[0]
+    assert_equal_event_time(TEST_TIME, emits[0][1])
   end
 end
diff --git a/test/plugin/test_in_forward.rb b/test/plugin/test_in_forward.rb
index 36d5b41d18..4323dcf921 100644
--- a/test/plugin/test_in_forward.rb
+++ b/test/plugin/test_in_forward.rb
@@ -1,6 +1,12 @@
 require_relative '../helper'
 require 'fluent/test'
 require 'base64'
+require 'socket'
+require 'openssl'
+require 'json'
+require 'msgpack'
+
+require 'fluent/plugin/in_forward'
 
 class ForwardInputTest < Test::Unit::TestCase
   def setup
@@ -8,14 +14,67 @@ def setup
     @responses = []  # for testing responses after sending data
   end
 
-  PORT = unused_port
+  PORT, REMOTE_PORT = unused_port(2) # REMOTE_PORT is used for dummy source of heartbeat
+
+  SHARED_KEY = 'foobar2'
+  USER_NAME = 'tagomoris'
+  USER_PASSWORD = 'fluentd'
+
   CONFIG = %[
     port #{PORT}
     bind 127.0.0.1
   ]
+  SSL_CONFIG = %[
+    port #{PORT}
+    bind 127.0.0.1
+    <ssl>
+      version TLSv1.2
+      cert_auto_generate yes
+      digest SHA512
+      algorithm RSA
+      key_length 4096
+    </ssl>
+  ]
+  CONFIG_AUTH = %[
+    port #{PORT}
+    bind 127.0.0.1
+    <security>
+      shared_key foobar1
+      user_auth true
+      <user>
+        username #{USER_NAME}
+        password #{USER_PASSWORD}
+      </user>
+      <client>
+        network 127.0.0.0/8
+        shared_key #{SHARED_KEY}
+        users ["#{USER_NAME}"]
+      </client>
+    </security>
+  ]
+  SSL_CONFIG_AUTH = %[
+    port #{PORT}
+    bind 127.0.0.1
+    <ssl>
+      cert_auto_generate yes
+    </ssl>
+    <security>
+      shared_key foobar1
+      user_auth true
+      <user>
+        username #{USER_NAME}
+        password #{USER_PASSWORD}
+      </user>
+      <client>
+        network 127.0.0.0/8
+        shared_key #{SHARED_KEY}
+        users ["#{USER_NAME}"]
+      </client>
+    </security>
+  ]
 
   def create_driver(conf=CONFIG)
-    Fluent::Test::InputTestDriver.new(Fluent::ForwardInput).configure(conf)
+    Fluent::Test::Driver::Input.new(Fluent::Plugin::ForwardInput).configure(conf)
   end
 
   def test_configure
@@ -23,120 +82,187 @@ def test_configure
     assert_equal PORT, d.instance.port
     assert_equal '127.0.0.1', d.instance.bind
     assert_equal 0, d.instance.linger_timeout
-    assert_equal 0.5, d.instance.blocking_timeout
     assert !d.instance.backlog
   end
 
-  # TODO: Will add Loop::run arity check with stub/mock library
+  def test_configure_auth
+    d = create_driver(CONFIG_AUTH)
+    assert_equal PORT, d.instance.port
+    assert_equal '127.0.0.1', d.instance.bind
+    assert_equal 0, d.instance.linger_timeout
+    assert !d.instance.backlog
+
+    assert d.instance.security
+    assert_equal 1, d.instance.security.users.size
+    assert_equal 1, d.instance.security.clients.size
+  end
+
+  def test_configure_ssl
+    d = create_driver(SSL_CONFIG)
+    assert_equal PORT, d.instance.port
+    assert_equal '127.0.0.1', d.instance.bind
+    assert d.instance.ssl_options
+    assert_equal :TLSv1_2, d.instance.ssl_options.version
+    assert d.instance.ssl_options.cert_auto_generate
+    assert_equal OpenSSL::Digest::SHA512, d.instance.ssl_options.digest
+    assert_equal OpenSSL::PKey::RSA, d.instance.ssl_options.algorithm
+    assert_equal 4096, d.instance.ssl_options.key_length
+  end
 
   def connect
     TCPSocket.new('127.0.0.1', PORT)
   end
 
+  def connect_ssl
+    sock = OpenSSL::SSL::SSLSocket.new(TCPSocket.new('127.0.0.1', PORT))
+    sock.sync = true
+    sock.sync_close = true
+    sock.connect
+    sock
+  end
+
   def test_time
     d = create_driver
 
     time = Fluent::EventTime.parse("2011-01-02 13:14:15 UTC")
     Fluent::Engine.now = time
 
-    d.expect_emit "tag1", time, {"a"=>1}
-    d.expect_emit "tag2", time, {"a"=>2}
+    records = [
+      ["tag", time, {"a" => 1}],
+      ["tag2", time, {"a" => 2}],
+    ]
 
+    d.expected_emits_length = records.length
+    d.run_timeout = 2
     d.run do
-      d.expected_emits.each {|tag,time,record|
-        send_data Fluent::Engine.msgpack_factory.packer.write([tag, 0, record]).to_s
+      records.each {|tag,time,record|
+        send_data false, false, Fluent::Engine.msgpack_factory.packer.write([tag, 0, record]).to_s
       }
     end
+    assert_equal records, d.emits.sort{|a,b| a[0] <=> b[0] }
   end
 
+  data('tcp' => [CONFIG, false], 'ssl' => [SSL_CONFIG, true])
   def test_message
-    d = create_driver
+    conf, ssl = data
+    d = create_driver(conf)
 
     time = Fluent::EventTime.parse("2011-01-02 13:14:15 UTC")
 
-    d.expect_emit "tag1", time, {"a"=>1}
-    d.expect_emit "tag2", time, {"a"=>2}
-
+    records = [
+      ["tag1", time, {"a"=>1}],
+      ["tag2", time, {"a"=>2}],
+    ]
     d.run do
-      d.expected_emits.each {|tag,time,record|
-        send_data Fluent::Engine.msgpack_factory.packer.write([tag, time, record]).to_s
+      records.each {|tag,time,record|
+        send_data ssl, Fluent::Engine.msgpack_factory.packer.write([tag, time, record]).to_s
       }
     end
+    assert_equal records[0], d.emits[0]
+    assert_equal records[1], d.emits[1]
   end
 
+  data('tcp' => [CONFIG, false], 'ssl' => [SSL_CONFIG, true])
   def test_message_with_time_as_integer
-    d = create_driver
+    conf, ssl = data
+    d = create_driver(conf)
 
     time = Time.parse("2011-01-02 13:14:15 UTC").to_i
 
-    d.expect_emit "tag1", time, {"a"=>1}
-    d.expect_emit "tag2", time, {"a"=>2}
+    records = [
+      ["tag1", time, {"a"=>1}],
+      ["tag2", time+1, {"a"=>2}],
+    ]
 
+    d.expected_emits_length = records.length
+    d.run_timeout = 2
     d.run do
-      d.expected_emits.each {|tag,time,record|
-        send_data Fluent::Engine.msgpack_factory.packer.write([tag, time, record]).to_s
+      records.each {|tag,time,record|
+        send_data ssl, false, Fluent::Engine.msgpack_factory.packer.write([tag, time, record]).to_s
       }
     end
+    assert_equal records[0], d.emits[0]
+    assert_equal records[1], d.emits[1]
   end
 
+  data('tcp' => [CONFIG, false, false], 'ssl' => [SSL_CONFIG, false, true])
   def test_message_with_skip_invalid_event
-    d = create_driver(CONFIG + "skip_invalid_event true")
+    conf, auth, ssl = data
+    d = create_driver(conf + "skip_invalid_event true")
 
     time = Fluent::EventTime.parse("2011-01-02 13:14:15 UTC")
 
-    d.expect_emit "tag1", time, {"a" => 1}
-    d.expect_emit "tag2", time, {"a" => 2}
+    records = [
+      ["tag1", time, {"a" => 1}],
+      ["tag2", time, {"a" => 2}],
+    ]
 
     d.run do
-      entries = d.expected_emits.map { |tag, time, record| [tag, time, record] }
       # These entries are skipped
-      entries << ['tag1', true, {'a' => 3}] << ['tag2', time, 'invalid record']
+      records << ['tag1', true, {'a' => 3}] << ['tag2', time, 'invalid record']
 
-      entries.each { |tag, time, record|
+      records.each { |tag, time, record|
         # Without ack, logs are sometimes not saved to logs during test.
-        send_data Fluent::Engine.msgpack_factory.packer.write([tag, time, record]).to_s, true
+        send_data auth, ssl, Fluent::Engine.msgpack_factory.packer.write([tag, time, record]).to_s, true
       }
     end
-
     assert_equal 2, d.instance.log.logs.count { |line| line =~ /got invalid event and drop it/ }
+    assert_equal records[0], d.emits[0]
+    assert_equal records[1], d.emits[1]
   end
 
-  def test_forward
-    d = create_driver
+  data('tcp' => [CONFIG, false, false], 'ssl' => [SSL_CONFIG, false, true], 'auth' => [CONFIG_AUTH, true, false], 'auth_ssl' => [SSL_CONFIG_AUTH, true, true])
+  def test_forward(data)
+    conf, auth, ssl = data
+    d = create_driver(conf)
 
     time = Fluent::EventTime.parse("2011-01-02 13:14:15 UTC")
 
-    d.expect_emit "tag1", time, {"a"=>1}
-    d.expect_emit "tag1", time, {"a"=>2}
+    records = [
+      ["tag1", time, {"a"=>1}],
+      ["tag1", time, {"a"=>2}],
+    ]
 
     d.run do
       entries = []
-      d.expected_emits.each {|tag,time,record|
+      records.each {|tag,time,record|
         entries << [time, record]
       }
-      send_data Fluent::Engine.msgpack_factory.packer.write(["tag1", entries]).to_s
+      send_data auth, ssl, Fluent::Engine.msgpack_factory.packer.write(["tag1", entries]).to_s
     end
+    assert_equal records[0], d.emits[0]
+    assert_equal records[1], d.emits[1]
   end
 
+  data('tcp' => [CONFIG, false, false], 'ssl' => [SSL_CONFIG, false, true], 'auth' => [CONFIG_AUTH, true, false], 'auth_ssl' => [SSL_CONFIG_AUTH, true, true])
   def test_forward_with_time_as_integer
-    d = create_driver
+    conf, auth, ssl = data
+    d = create_driver(conf)
 
     time = Time.parse("2011-01-02 13:14:15 UTC").to_i
 
-    d.expect_emit "tag1", time, {"a"=>1}
-    d.expect_emit "tag1", time, {"a"=>2}
+    records = [
+      ["tag1", time, {"a"=>1}],
+      ["tag1", time+1, {"a"=>2}],
+    ]
 
+    d.expected_emits_length = records.length
+    d.run_timeout = 2
     d.run do
       entries = []
-      d.expected_emits.each {|tag,time,record|
+      records.each {|tag,time,record|
         entries << [time, record]
       }
-      send_data Fluent::Engine.msgpack_factory.packer.write(["tag1", entries]).to_s
+      send_data auth, ssl, Fluent::Engine.msgpack_factory.packer.write(["tag1", entries]).to_s
     end
+    assert_equal records[0], d.emits[0]
+    assert_equal records[1], d.emits[1]
   end
 
+  data('tcp' => [CONFIG, false, false], 'ssl' => [SSL_CONFIG, false, true], 'auth' => [CONFIG_AUTH, true, false], 'auth_ssl' => [SSL_CONFIG_AUTH, true, true])
   def test_forward_with_skip_invalid_event
-    d = create_driver(CONFIG + "skip_invalid_event true")
+    conf, auth, ssl = data
+    d = create_driver(conf + "skip_invalid_event true")
 
     time = Fluent::EventTime.parse("2011-01-02 13:14:15 UTC")
 
@@ -148,56 +274,75 @@ def test_forward_with_skip_invalid_event
       # These entries are skipped
       entries << ['invalid time', {'a' => 3}] << [time, 'invalid record']
 
-      send_data Fluent::Engine.msgpack_factory.packer.write(["tag1", entries]).to_s
+      send_data auth, ssl, Fluent::Engine.msgpack_factory.packer.write(["tag1", entries]).to_s
     end
-
     assert_equal 2, d.instance.log.logs.count { |line| line =~ /skip invalid event/ }
+    assert_equal records[0], d.emits[0]
+    assert_equal records[1], d.emits[1]
   end
 
-  def test_packed_forward
-    d = create_driver
+  data('tcp' => [CONFIG, false, false], 'ssl' => [SSL_CONFIG, false, true], 'auth' => [CONFIG_AUTH, true, false], 'auth_ssl' => [SSL_CONFIG_AUTH, true, true])
+  def test_packed_forward(data)
+    conf, auth, ssl = data
+    d = create_driver(conf)
 
     time = Fluent::EventTime.parse("2011-01-02 13:14:15 UTC")
 
-    d.expect_emit "tag1", time, {"a"=>1}
-    d.expect_emit "tag1", time, {"a"=>2}
+    records = [
+      ["tag1", time, {"a"=>1}],
+      ["tag1", time, {"a"=>2}],
+    ]
 
     d.run do
       entries = ''
-      d.expected_emits.each {|tag,time,record|
+      records.each {|tag,time,record|
         Fluent::Engine.msgpack_factory.packer(entries).write([time, record]).flush
       }
-      send_data Fluent::Engine.msgpack_factory.packer.write(["tag1", entries]).to_s
+      send_data auth, ssl, Fluent::Engine.msgpack_factory.packer.write(["tag1", entries]).to_s
     end
+    assert_equal records[0], d.emits[0]
+    assert_equal records[1], d.emits[1]
   end
 
+  data('tcp' => [CONFIG, false, false], 'ssl' => [SSL_CONFIG, false, true], 'auth' => [CONFIG_AUTH, true, false], 'auth_ssl' => [SSL_CONFIG_AUTH, true, true])
   def test_packed_forward_with_time_as_integer
+    conf, auth, ssl = data
     d = create_driver
 
     time = Time.parse("2011-01-02 13:14:15 UTC").to_i
 
-    d.expect_emit "tag1", time, {"a"=>1}
-    d.expect_emit "tag1", time, {"a"=>2}
+    records = [
+      ["tag1", time, {"a"=>1}],
+      ["tag1", time+1, {"a"=>2}],
+    ]
 
+    d.expected_emits_length = records.length
+    d.run_timeout = 2
     d.run do
       entries = ''
-      d.expected_emits.each {|tag,time,record|
+      records.each {|tag,time,record|
         Fluent::Engine.msgpack_factory.packer(entries).write([time, record]).flush
       }
-      send_data Fluent::Engine.msgpack_factory.packer.write(["tag1", entries]).to_s
+      send_data auth, ssl, Fluent::Engine.msgpack_factory.packer.write(["tag1", entries]).to_s
     end
+    assert_equal records[0], d.emits[0]
+    assert_equal records[1], d.emits[1]
   end
 
+  data('tcp' => [CONFIG, false, false], 'ssl' => [SSL_CONFIG, false, true], 'auth' => [CONFIG_AUTH, true, false], 'auth_ssl' => [SSL_CONFIG_AUTH, true, true])
   def test_packed_forward_with_skip_invalid_event
-    d = create_driver(CONFIG + "skip_invalid_event true")
+    conf, auth, ssl = data
+    d = create_driver(conf + "skip_invalid_event true")
 
     time = Fluent::EventTime.parse("2011-01-02 13:14:15 UTC")
 
-    d.expect_emit "tag1", time, {"a" => 1}
-    d.expect_emit "tag1", time, {"a" => 2}
+    records = [
+      ["tag1", time, {"a" => 1}],
+      ["tag1", time, {"a" => 2}],
+    ]
 
     d.run do
-      entries = d.expected_emits.map { |tag ,time, record| [time, record] }
+      entries = records.map { |tag, time, record| [time, record] }
       # These entries are skipped
       entries << ['invalid time', {'a' => 3}] << [time, 'invalid record']
 
@@ -205,25 +350,33 @@ def test_packed_forward_with_skip_invalid_event
       entries.each { |time, record|
         Fluent::Engine.msgpack_factory.packer(packed_entries).write([time, record]).flush
       }
-      send_data Fluent::Engine.msgpack_factory.packer.write(["tag1", packed_entries]).to_s
+      send_data auth, ssl, Fluent::Engine.msgpack_factory.packer.write(["tag1", packed_entries]).to_s
     end
-
     assert_equal 2, d.instance.log.logs.count { |line| line =~ /skip invalid event/ }
+    assert_equal records[0], d.emits[0]
+    assert_equal records[1], d.emits[1]
   end
 
-  def test_message_json
-    d = create_driver
+  data('tcp' => [CONFIG, false, false], 'ssl' => [SSL_CONFIG, false, true]) # with json, auth doesn't work
+  def test_message_json(data)
+    conf, auth, ssl = data
+    d = create_driver(conf)
 
     time = Time.parse("2011-01-02 13:14:15 UTC").to_i
 
-    d.expect_emit "tag1", time, {"a"=>1}
-    d.expect_emit "tag2", time, {"a"=>2}
+    records = [
+      ["tag1", time, {"a"=>1}],
+      ["tag2", time+1, {"a"=>2}],
+    ]
 
+    d.expected_emits_length = records.length
+    d.run_timeout = 2
     d.run do
-      d.expected_emits.each {|tag,time,record|
-        send_data [tag, time, record].to_json
+      records.each {|tag,time,record|
+        send_data auth, ssl, [tag, time, record].to_json
       }
     end
+    assert_equal records, d.emits.sort{|a,b| a[1] <=> b[1] }
   end
 
   def test_send_large_chunk_warning
@@ -240,9 +393,11 @@ def test_send_large_chunk_warning
     assert chunk.size > (16 * 1024 * 1024)
     assert chunk.size < (32 * 1024 * 1024)
 
+    d.expected_emits_length = 16
+    d.run_timeout = 2
     d.run do
       Fluent::Engine.msgpack_factory.unpacker.feed_each(chunk) do |obj|
-        d.instance.send(:on_message, obj, chunk.size, "host: 127.0.0.1, addr: 127.0.0.1, port: 0000")
+        d.instance.send(:emit_message, obj, chunk.size, "host: 127.0.0.1, addr: 127.0.0.1, port: 0000")
       end
     end
 
@@ -269,9 +424,11 @@ def test_send_large_chunk_only_warning
     str = "X" * 1024 * 1024
     chunk = [ "test.tag", (0...16).map{|i| [time + i, {"data" => str}] } ].to_msgpack
 
+    d.expected_emits_length = 16
+    d.run_timeout = 2
     d.run do
       Fluent::Engine.msgpack_factory.unpacker.feed_each(chunk) do |obj|
-        d.instance.send(:on_message, obj, chunk.size, "host: 127.0.0.1, addr: 127.0.0.1, port: 0000")
+        d.instance.send(:emit_message, obj, chunk.size, "host: 127.0.0.1, addr: 127.0.0.1, port: 0000")
       end
     end
 
@@ -295,10 +452,14 @@ def test_send_large_chunk_limit
     chunk = [ "test.tag", (0...32).map{|i| [time + i, {"data" => str}] } ].to_msgpack
     assert chunk.size > (32 * 1024 * 1024)
 
+    d.end_if {
+      d.instance.log.logs.select{|line| line =~ / \[warn\]: Input chunk size is larger than 'chunk_size_limit', dropped:/ }.size == 1
+    }
+    d.run_timeout = 2
     # d.run => send_data
     d.run do
       Fluent::Engine.msgpack_factory.unpacker.feed_each(chunk) do |obj|
-        d.instance.send(:on_message, obj, chunk.size, "host: 127.0.0.1, addr: 127.0.0.1, port: 0000")
+        d.instance.send(:emit_message, obj, chunk.size, "host: 127.0.0.1, addr: 127.0.0.1, port: 0000")
       end
     end
 
@@ -333,16 +494,19 @@ def test_send_broken_chunk(data)
     }.size == 1, "should not accept broken chunk"
   end
 
-  def test_respond_to_message_requiring_ack
-    d = create_driver
+  data('tcp' => [CONFIG, false, false], 'ssl' => [SSL_CONFIG, false, true], 'auth' => [CONFIG_AUTH, true, false], 'auth_ssl' => [SSL_CONFIG_AUTH, true, true])
+  def test_respond_to_message_requiring_ack(data)
+    conf, auth, ssl = data
+    d = create_driver(conf)
 
     time = Fluent::EventTime.parse("2011-01-02 13:14:15 UTC")
 
     events = [
       ["tag1", time, {"a"=>1}],
-      ["tag2", time, {"a"=>2}]
+      ["tag2", time+1, {"a"=>2}]
     ]
     d.expected_emits_length = events.length
+    d.run_timeout = 2
 
     expected_acks = []
 
@@ -350,25 +514,27 @@ def test_respond_to_message_requiring_ack
       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, true
+        send_data auth, ssl, [tag, time, record, op].to_msgpack, true
       }
     end
 
-    assert_equal events, d.emits
+    assert_equal events, d.emits.sort{|a,b| a[1] <=> b[1] }
     assert_equal expected_acks, @responses.map { |res| MessagePack.unpack(res)['ack'] }
   end
 
-  # FIX: response is not pushed into @responses because IO.select has been blocked until InputForward shutdowns
-  def test_respond_to_forward_requiring_ack
-    d = create_driver
+  data('tcp' => [CONFIG, false, false], 'ssl' => [SSL_CONFIG, false, true], 'auth' => [CONFIG_AUTH, true, false], 'auth_ssl' => [SSL_CONFIG_AUTH, true, true])
+  def test_respond_to_forward_requiring_ack(data)
+    conf, auth, ssl = data
+    d = create_driver(conf)
 
     time = Fluent::EventTime.parse("2011-01-02 13:14:15 UTC")
 
     events = [
       ["tag1", time, {"a"=>1}],
-      ["tag1", time, {"a"=>2}]
+      ["tag1", time+1, {"a"=>2}]
     ]
     d.expected_emits_length = events.length
+    d.run_timeout = 2
 
     expected_acks = []
 
@@ -379,23 +545,26 @@ def test_respond_to_forward_requiring_ack
       }
       op = { 'chunk' => Base64.encode64(entries.object_id.to_s) }
       expected_acks << op['chunk']
-      send_data ["tag1", entries, op].to_msgpack, true
+      send_data auth, ssl, ["tag1", entries, op].to_msgpack, true
     end
 
-    assert_equal events, d.emits
+    assert_equal events, d.emits.sort{|a,b| a[1] <=> b[1] }
     assert_equal expected_acks, @responses.map { |res| MessagePack.unpack(res)['ack'] }
   end
 
-  def test_respond_to_packed_forward_requiring_ack
-    d = create_driver
+  data('tcp' => [CONFIG, false, false], 'ssl' => [SSL_CONFIG, false, true], 'auth' => [CONFIG_AUTH, true, false], 'auth_ssl' => [SSL_CONFIG_AUTH, true, true])
+  def test_respond_to_packed_forward_requiring_ack(data)
+    conf, auth, ssl = data
+    d = create_driver(conf)
 
     time = Fluent::EventTime.parse("2011-01-02 13:14:15 UTC")
 
     events = [
       ["tag1", time, {"a"=>1}],
-      ["tag1", time, {"a"=>2}]
+      ["tag1", time+1, {"a"=>2}]
     ]
     d.expected_emits_length = events.length
+    d.run_timeout = 2
 
     expected_acks = []
 
@@ -406,23 +575,26 @@ def test_respond_to_packed_forward_requiring_ack
       }
       op = { 'chunk' => Base64.encode64(entries.object_id.to_s) }
       expected_acks << op['chunk']
-      send_data ["tag1", entries, op].to_msgpack, true
+      send_data auth, ssl, ["tag1", entries, op].to_msgpack, true
     end
 
-    assert_equal events, d.emits
+    assert_equal events, d.emits.sort{|a,b| a[1] <=> b[1] }
     assert_equal expected_acks, @responses.map { |res| MessagePack.unpack(res)['ack'] }
   end
 
-  def test_respond_to_message_json_requiring_ack
-    d = create_driver
+  data('tcp' => [CONFIG, false, false], 'ssl' => [SSL_CONFIG, false, true]) # with json, auth doesn't work
+  def test_respond_to_message_json_requiring_ack(data)
+    conf, auth, ssl = data
+    d = create_driver(conf)
 
     time = Time.parse("2011-01-02 13:14:15 UTC").to_i
 
     events = [
       ["tag1", time, {"a"=>1}],
-      ["tag2", time, {"a"=>2}]
+      ["tag2", time+1, {"a"=>2}]
     ]
     d.expected_emits_length = events.length
+    d.run_timeout = 2
 
     expected_acks = []
 
@@ -430,118 +602,398 @@ def test_respond_to_message_json_requiring_ack
       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, true
+        send_data auth, ssl, [tag, time, record, op].to_json, true
       }
     end
 
-    assert_equal events, d.emits
+    assert_equal events, d.emits.sort{|a,b| a[1] <=> b[1] }
     assert_equal expected_acks, @responses.map { |res| JSON.parse(res)['ack'] }
-
   end
 
-  def test_not_respond_to_message_not_requiring_ack
-    d = create_driver
+  data('tcp' => [CONFIG, false, false], 'ssl' => [SSL_CONFIG, false, true], 'auth' => [CONFIG_AUTH, true, false], 'auth_ssl' => [SSL_CONFIG_AUTH, true, true])
+  def test_not_respond_to_message_not_requiring_ack(data)
+    conf, auth, ssl = data
+    d = create_driver(conf)
 
     time = Fluent::EventTime.parse("2011-01-02 13:14:15 UTC")
 
     events = [
       ["tag1", time, {"a"=>1}],
-      ["tag2", time, {"a"=>2}]
+      ["tag2", time+1, {"a"=>2}]
     ]
     d.expected_emits_length = events.length
+    d.run_timeout = 2
 
     d.run do
       events.each {|tag,time,record|
-        send_data [tag, time, record].to_msgpack, true
+        send_data auth, ssl, [tag, time, record].to_msgpack, true
       }
     end
 
-    assert_equal events, d.emits
-    assert_equal [nil, nil], @responses
+    assert_equal events, d.emits.sort{|a,b| a[1] <=> b[1] }
+    assert_equal ["", ""], @responses
   end
 
-  def test_not_respond_to_forward_not_requiring_ack
-    d = create_driver
+  data('tcp' => [CONFIG, false, false], 'ssl' => [SSL_CONFIG, false, true], 'auth' => [CONFIG_AUTH, true, false], 'auth_ssl' => [SSL_CONFIG_AUTH, true, true])
+  def test_not_respond_to_forward_not_requiring_ack(data)
+    conf, auth, ssl = data
+    d = create_driver(conf)
 
     time = Fluent::EventTime.parse("2011-01-02 13:14:15 UTC")
 
     events = [
       ["tag1", time, {"a"=>1}],
-      ["tag1", time, {"a"=>2}]
+      ["tag1", time+1, {"a"=>2}]
     ]
     d.expected_emits_length = events.length
+    d.run_timeout = 2
 
     d.run do
       entries = []
       events.each {|tag,time,record|
         entries << [time, record]
       }
-      send_data ["tag1", entries].to_msgpack, true
+      send_data auth, ssl, ["tag1", entries].to_msgpack, true
     end
 
-    assert_equal events, d.emits
-    assert_equal [nil], @responses
+    assert_equal events, d.emits.sort{|a,b| a[1] <=> b[1] }
+    assert_equal [""], @responses
   end
 
-  def test_not_respond_to_packed_forward_not_requiring_ack
-    d = create_driver
+  data('tcp' => [CONFIG, false, false], 'ssl' => [SSL_CONFIG, false, true], 'auth' => [CONFIG_AUTH, true, false], 'auth_ssl' => [SSL_CONFIG_AUTH, true, true])
+  def test_not_respond_to_packed_forward_not_requiring_ack(data)
+    conf, auth, ssl = data
+    d = create_driver(conf)
 
     time = Fluent::EventTime.parse("2011-01-02 13:14:15 UTC")
 
     events = [
       ["tag1", time, {"a"=>1}],
-      ["tag1", time, {"a"=>2}]
+      ["tag1", time+1, {"a"=>2}]
     ]
     d.expected_emits_length = events.length
+    d.run_timeout = 2
 
     d.run do
       entries = ''
       events.each {|tag,time,record|
         [time, record].to_msgpack(entries)
       }
-      send_data ["tag1", entries].to_msgpack, true
+      send_data auth, ssl, ["tag1", entries].to_msgpack, true
     end
 
-    assert_equal events, d.emits
-    assert_equal [nil], @responses
+    assert_equal events, d.emits.sort{|a,b| a[1] <=> b[1] }
+    assert_equal [""], @responses
   end
 
-  def test_not_respond_to_message_json_not_requiring_ack
-    d = create_driver
+  data('tcp' => [CONFIG, false, false], 'ssl' => [SSL_CONFIG, false, true]) # with json, auth doen NOT work
+  def test_not_respond_to_message_json_not_requiring_ack(data)
+    conf, auth, ssl = data
+    d = create_driver(conf)
 
     time = Time.parse("2011-01-02 13:14:15 UTC").to_i
 
     events = [
       ["tag1", time, {"a"=>1}],
-      ["tag2", time, {"a"=>2}]
+      ["tag2", time+1, {"a"=>2}]
     ]
     d.expected_emits_length = events.length
+    d.run_timeout = 2
 
     d.run do
       events.each {|tag,time,record|
-        send_data [tag, time, record].to_json, true
+        send_data auth, ssl, [tag, time, record].to_json, true
       }
     end
 
-    assert_equal events, d.emits
-    assert_equal [nil, nil], @responses
+    assert_equal events, d.emits.sort{|a,b| a[1] <=> b[1] }
+    assert_equal ["", ""], @responses
+  end
+
+  def test_heartbeat_reply
+    heartbeat_data = nil
+    heartbeat_addr = nil
+
+    bind = '0.0.0.0'
+    listener_thread = Thread.new {
+      usock = if IPAddr.new(IPSocket.getaddress(bind)).ipv4?
+                    UDPSocket.new
+                  else
+                    UDPSocket.new(::Socket::AF_INET6)
+                  end
+      usock.bind(bind, REMOTE_PORT)
+      heartbeat_arrived = false
+      until heartbeat_arrived
+        if IO.select([usock])
+          heartbeat_data, heartbeat_addr = usock.recvfrom_nonblock(1024)
+          heartbeat_arrived = true
+        end
+      end
+    }
+    until listener_thread.alive?
+      sleep 0.01
+    end
+
+    d = create_driver
+    d.end_if { ! heartbeat_data.nil? }
+    d.run_timeout = 60
+    d.run do
+      sock = if IPAddr.new(IPSocket.getaddress(bind)).ipv4?
+               UDPSocket.new
+             else
+               UDPSocket.new(::Socket::AF_INET6)
+             end
+      until heartbeat_data
+        sock.send("\0", 0, '127.0.0.1', REMOTE_PORT)
+        unless heartbeat_data
+          sleep 1
+        end
+      end
+    end
+
+    assert_equal "\0", heartbeat_data
+    assert_equal "127.0.0.1", heartbeat_addr[2]
+  end
+
+  CONFIG_AUTH_TEST = %[
+    port #{PORT}
+    bind 127.0.0.1
+    <security>
+      shared_key foobar1
+      user_auth true
+      <user>
+        username #{USER_NAME}
+        password #{USER_PASSWORD}
+      </user>
+      <client>
+        network 127.0.0.0/8
+        shared_key #{SHARED_KEY}
+      </client>
+    </security>
+  ]
+
+  data('tcp' => false, 'ssl' => true)
+  def test_auth_invalid_shared_key(data)
+    ssl = data
+    conf = if ssl
+             CONFIG_AUTH_TEST + %[<ssl>\n cert_auto_generate yes \n</ssl>\n]
+           else
+             CONFIG_AUTH_TEST
+           end
+    d = create_driver(conf)
+    error = nil
+    d.run do
+      io = ssl ? connect_ssl : connect
+      begin
+        simulate_auth_sequence(io, 'fake shared key', USER_NAME, USER_PASSWORD)
+      rescue => e
+        error = e
+        # "assert_raise" raises LocalJumpError here
+      end
+    end
+    assert_equal RuntimeError, error.class
+    assert_equal "Authentication Failure: shared_key mismatch", error.message
+  end
+
+  data('tcp' => false, 'ssl' => true)
+  def test_auth_invalid_password(data)
+    ssl = data
+    conf = if ssl
+             CONFIG_AUTH_TEST + %[<ssl>\n cert_auto_generate yes \n</ssl>\n]
+           else
+             CONFIG_AUTH_TEST
+           end
+    d = create_driver(conf)
+    error = nil
+    d.run do
+      io = ssl ? connect_ssl : connect
+      begin
+        simulate_auth_sequence(io, SHARED_KEY, USER_NAME, 'fake-password')
+      rescue RuntimeError => e
+        error = e
+        # "assert_raise" raises LocalJumpError here
+      end
+    end
+    assert_equal "Authentication Failure: username/password mismatch", error.message
+  end
+
+  CONFIG_AUTH_TEST_2 = %[
+    port #{PORT}
+    bind 127.0.0.1
+    <security>
+      shared_key foobar1
+      user_auth true
+      <user>
+        username tagomoris
+        password fluentd
+      </user>
+      <user>
+        username frsyuki
+        password embulk
+      </user>
+      <client>
+        network 127.0.0.0/8
+        shared_key #{SHARED_KEY}
+        users ["tagomoris"]
+      </client>
+    </security>
+  ]
+
+  data('tcp' => false, 'ssl' => true)
+  def test_auth_disallowed_user(data)
+    ssl = data
+    conf = if ssl
+             CONFIG_AUTH_TEST_2 + %[<ssl>\n cert_auto_generate yes \n</ssl>\n]
+           else
+             CONFIG_AUTH_TEST_2
+           end
+    d = create_driver(conf)
+    error = nil
+    d.run do
+      io = ssl ? connect_ssl : connect
+      begin
+        simulate_auth_sequence(io, SHARED_KEY, 'frsyuki', 'embulk')
+      rescue RuntimeError => e
+        error = e
+        # "assert_raise" raises LocalJumpError here
+      end
+    end
+    assert_equal "Authentication Failure: username/password mismatch", error.message
   end
 
-  def send_data(data, try_to_receive_response=false, response_timeout=1)
-    io = connect
+  CONFIG_AUTH_TEST_3 = %[
+    port #{PORT}
+    bind 127.0.0.1
+    <security>
+      shared_key foobar1
+      user_auth true
+      allow_anonymous_source no
+      <user>
+        username tagomoris
+        password fluentd
+      </user>
+      <client>
+        network 192.168.0.0/24
+        shared_key #{SHARED_KEY}
+        users ["tagomoris"]
+      </client>
+    </security>
+  ]
+
+  data('tcp' => false, 'ssl' => true)
+  def test_auth_anonymous_host(data)
+    ssl = data
+    conf = if ssl
+             CONFIG_AUTH_TEST_3 + %[<ssl>\n cert_auto_generate yes \n</ssl>\n]
+           else
+             CONFIG_AUTH_TEST_3
+           end
+    d = create_driver(conf)
+    error = nil
+    d.run do
+      io = ssl ? connect_ssl : connect
+      begin
+        simulate_auth_sequence(io, SHARED_KEY, 'frsyuki', 'embulk')
+      rescue RuntimeError => e
+        error = e
+        # "assert_raise" raises LocalJumpError here
+      end
+    end
+    assert_equal "Authentication Failure: anonymous source host '127.0.0.1' denied", error.message
+  end
+
+  # res
+  # '' : socket is disconnected without any data
+  # nil: socket read timeout
+  def read_data(io, timeout)
+    res = ''
+    timeout_at = Time.now + timeout
     begin
-      io.write data
-      if try_to_receive_response
-        if IO.select([io], nil, nil, response_timeout)
-          res = io.recv(1024)
+      buf = ''
+      while io.read_nonblock(2048, buf)
+        if buf == ''
+          sleep 0.01
+          break if Time.now >= timeout_at
+          next
         end
-        # timeout means no response, so push nil to @responses
+        res << buf
+        buf = ''
       end
-    ensure
-      io.close
+      res = nil # timeout
+    rescue IO::EAGAINWaitReadable
+      sleep 0.01
+      retry if res == ''
+      # if res is not empty, all data in socket buffer are read, so do not retry
+    rescue OpenSSL::SSL::SSLErrorWaitReadable
+      sleep 0.01
+      retry if res == ''
+      # if res is not empty, all data in socket buffer are read, so do not retry
+    rescue IOError, EOFError, Errno::ECONNRESET
+      # socket disconnected
+    end
+    res
+  end
+
+  def simulate_auth_sequence(io, shared_key=SHARED_KEY, username=USER_NAME, password=USER_PASSWORD)
+    auth_response_timeout = 2
+    shared_key_salt = 'salt'
+
+    # reading helo
+    helo_data = read_data(io, auth_response_timeout)
+    # ['HELO', options(hash)]
+    helo = MessagePack.unpack(helo_data)
+    raise "Invalid HELO header" unless helo[0] == 'HELO'
+    raise "Invalid HELO option object" unless helo[1].is_a?(Hash)
+    @options = helo[1]
+
+    # sending ping
+    ping = [
+      'PING',
+      'selfhostname',
+      shared_key_salt,
+      Digest::SHA512.new.update(shared_key_salt).update('selfhostname').update(shared_key).hexdigest,
+    ]
+    if @options['auth'] # auth enabled -> value is auth salt
+      pass_digest = Digest::SHA512.new.update(@options['auth']).update(username).update(password).hexdigest
+      ping.push(username, pass_digest)
+    else
+      ping.push('', '')
+    end
+    io.write ping.to_msgpack
+    io.flush
+
+    # reading pong
+    pong_data = read_data(io, auth_response_timeout)
+    # ['PING', bool(auth_result), string(reason_if_failed), self_hostname, shared_key_digest]
+    pong = MessagePack.unpack(pong_data)
+    raise "Invalid PONG header" unless pong[0] == 'PONG'
+    raise "Authentication Failure: #{pong[2]}" unless pong[1]
+    clientside_calculated = Digest::SHA512.new.update(shared_key_salt).update(pong[3]).update(shared_key).hexdigest
+    raise "Shared key digest mismatch" unless clientside_calculated == pong[4]
+
+    # authentication success
+    true
+  end
+
+  # Data ordering is not assured:
+  #  Records in different sockets are processed on different thread, so its scheduling make effect
+  #  on order of emitted records.
+  #  So, we MUST sort emitted records in different `send_data` before assertion.
+  def send_data(auth, ssl, data, try_to_receive_response=false, response_timeout=5)
+    io = ssl ? connect_ssl : connect
+
+    if auth
+      simulate_auth_sequence(io)
+    end
+
+    res = nil
+    io.write data
+    io.flush
+    if try_to_receive_response
+      @responses << read_data(io, response_timeout)
     end
-    @responses << res if try_to_receive_response
+  ensure
+    io.close rescue nil # SSL socket requires any writes to close sockets
   end
 
-  # TODO heartbeat
 end
diff --git a/test/plugin/test_in_gc_stat.rb b/test/plugin/test_in_gc_stat.rb
deleted file mode 100644
index ff0638251f..0000000000
--- a/test/plugin/test_in_gc_stat.rb
+++ /dev/null
@@ -1,38 +0,0 @@
-require_relative '../helper'
-require 'fluent/test'
-
-class GCStatInputTest < Test::Unit::TestCase
-  def setup
-    Fluent::Test.setup
-  end
-
-  CONFIG = %[
-    emit_interval 1
-    tag t1
-  ]
-
-  def create_driver(conf=CONFIG)
-    Fluent::Test::InputTestDriver.new(Fluent::GCStatInput).configure(conf)
-  end
-
-  def test_configure
-    d = create_driver
-    assert_equal(1, d.instance.emit_interval)
-    assert_equal("t1", d.instance.tag)
-  end
-
-  def test_emit
-    stat = GC.stat
-    stub(GC).stat { stat }
-
-    d = create_driver
-    d.run do
-      sleep 2
-    end
-
-    emits = d.emits
-    assert(emits.length > 0)
-    assert_equal(stat, emits[0][2])
-    assert(emits[0][1].is_a?(Fluent::EventTime))
-  end
-end
diff --git a/test/plugin/test_in_http.rb b/test/plugin/test_in_http.rb
index 0ecc0706d4..0569378a34 100644
--- a/test/plugin/test_in_http.rb
+++ b/test/plugin/test_in_http.rb
@@ -1,6 +1,7 @@
 require_relative '../helper'
 require 'fluent/test'
 require 'net/http'
+require 'fluent/plugin/in_http'
 
 class HttpInputTest < Test::Unit::TestCase
   def setup
@@ -17,7 +18,7 @@ def setup
   ]
 
   def create_driver(conf=CONFIG)
-    Fluent::Test::InputTestDriver.new(Fluent::HttpInput).configure(conf, true)
+    Fluent::Test::Driver::Input.new(Fluent::Plugin::HttpInput).configure(conf, true)
   end
 
   def test_configure
@@ -33,17 +34,24 @@ def test_time
     d = create_driver
 
     time = Fluent::EventTime.new(Time.parse("2011-01-02 13:14:15 UTC").to_i)
+    # Why this sentence works well and does NOT effect any other tests?
     Fluent::Engine.now = time
 
-    d.expect_emit "tag1", time, {"a"=>1}
-    d.expect_emit "tag2", time, {"a"=>2}
+    expected = [
+      ["tag1", time, {"a"=>1}],
+      ["tag2", time, {"a"=>2}]
+    ]
 
     d.run do
-      d.expected_emits.each {|tag,time,record|
+      expected.each do |tag, time, record|
         res = post("/#{tag}", {"json"=>record.to_json})
         assert_equal "200", res.code
-      }
+      end
     end
+
+    assert_equal 2, d.emits.size
+    assert_equal expected[0], d.emits[0]
+    assert_equal expected[1], d.emits[1]
   end
 
   def test_time_as_float
@@ -67,16 +75,22 @@ def test_json
 
     time = Fluent::EventTime.new(Time.parse("2011-01-02 13:14:15 UTC").to_i)
 
-    d.expect_emit "tag1", time, {"a"=>1}
-    d.expect_emit "tag2", time, {"a"=>2}
+    expected = [
+      ["tag1", time, {"a"=>1}],
+      ["tag2", time, {"a"=>2}],
+    ]
 
     d.run do
-      d.expected_emits.each {|tag,time,record|
+      expected.each {|tag, time, record|
         res = post("/#{tag}", {"json"=>record.to_json, "time"=>time.to_s})
         assert_equal "200", res.code
       }
     end
 
+    assert_equal 2, d.emits.size
+    assert_equal expected[0], d.emits[0]
+    assert_equal expected[1], d.emits[1]
+
     d.emit_streams.each { |tag, es|
       assert !include_http_header?(es.first[1])
     }
@@ -90,15 +104,13 @@ def test_multi_json
     events = [{"a"=>1},{"a"=>2}]
     tag = "tag1"
 
-    events.each { |ev|
-      d.expect_emit tag, time, ev
-    }
-
     d.run do
       res = post("/#{tag}", {"json"=>events.to_json, "time"=>time.to_s})
       assert_equal "200", res.code
     end
 
+    assert_equal ["tag1", time, events[0]], d.emits[0]
+    assert_equal ["tag1", time, events[1]], d.emits[1]
   end
 
   def test_json_with_add_remote_addr
@@ -159,16 +171,15 @@ def test_json_with_add_http_headers
     records = [["tag1", time, {"a"=>1}], ["tag2", time, {"a"=>2}]]
 
     d.run do
-      records.each {|tag,time,record|
+      records.each do |tag,time,record|
         res = post("/#{tag}", {"json"=>record.to_json, "time"=>time.to_s})
         assert_equal "200", res.code
-
-      }
+      end
     end
 
-    d.emit_streams.each { |tag, es|
+    d.emit_streams.each do |tag, es|
       assert include_http_header?(es.first[1])
-    }
+    end
   end
 
   def test_application_json
@@ -176,15 +187,20 @@ def test_application_json
 
     time = Fluent::EventTime.new(Time.parse("2011-01-02 13:14:15 UTC").to_i)
 
-    d.expect_emit "tag1", time, {"a"=>1}
-    d.expect_emit "tag2", time, {"a"=>2}
+    expected = [
+      ["tag1", time, {"a"=>1}],
+      ["tag2", time, {"a"=>2}],
+    ]
 
     d.run do
-      d.expected_emits.each {|tag,time,record|
+      expected.each do |tag,time,record|
         res = post("/#{tag}?time=#{time.to_s}", record.to_json, {"content-type"=>"application/json; charset=utf-8"})
         assert_equal "200", res.code
-      }
+      end
     end
+
+    assert_equal expected[0], d.emits[0]
+    assert_equal expected[1], d.emits[1]
   end
 
   def test_msgpack
@@ -192,15 +208,20 @@ def test_msgpack
 
     time = Fluent::EventTime.new(Time.parse("2011-01-02 13:14:15 UTC").to_i)
 
-    d.expect_emit "tag1", time, {"a"=>1}
-    d.expect_emit "tag2", time, {"a"=>2}
+    expected = [
+      ["tag1", time, {"a"=>1}],
+      ["tag2", time, {"a"=>2}],
+    ]
 
     d.run do
-      d.expected_emits.each {|tag,time,record|
+      expected.each do |tag,time,record|
         res = post("/#{tag}", {"msgpack"=>record.to_msgpack, "time"=>time.to_s})
         assert_equal "200", res.code
-      }
+      end
     end
+
+    assert_equal expected[0], d.emits[0]
+    assert_equal expected[1], d.emits[1]
   end
 
   def test_multi_msgpack
@@ -211,15 +232,13 @@ def test_multi_msgpack
     events = [{"a"=>1},{"a"=>2}]
     tag = "tag1"
 
-    events.each { |ev|
-      d.expect_emit tag, time, ev
-    }
-
     d.run do
       res = post("/#{tag}", {"msgpack"=>events.to_msgpack, "time"=>time.to_s})
       assert_equal "200", res.code
     end
 
+    assert_equal ["tag1", time, events[0]], d.emits[0]
+    assert_equal ["tag1", time, events[1]], d.emits[1]
   end
 
   def test_with_regexp
@@ -230,18 +249,23 @@ def test_with_regexp
 
     time = Fluent::EventTime.new(Time.parse("2011-01-02 13:14:15 UTC").to_i)
 
-    d.expect_emit "tag1", time, {"field_1" => 1, "field_2" => 'str'}
-    d.expect_emit "tag2", time, {"field_1" => 2, "field_2" => 'str'}
+    expected = [
+      ["tag1", time, {"field_1" => 1, "field_2" => 'str'}],
+      ["tag2", time, {"field_1" => 2, "field_2" => 'str'}],
+    ]
 
     d.run do
-      d.expected_emits.each { |tag, time, record|
+      expected.each do |tag, time, record|
         body = record.map { |k, v|
           v.to_s
         }.join(':')
         res = post("/#{tag}?time=#{time.to_s}", body)
         assert_equal "200", res.code
-      }
+      end
     end
+
+    assert_equal expected[0], d.emits[0]
+    assert_equal expected[1], d.emits[1]
   end
 
   def test_with_csv
@@ -254,16 +278,21 @@ def test_with_csv
 
     time = Fluent::EventTime.new(Time.parse("2011-01-02 13:14:15 UTC").to_i)
 
-    d.expect_emit "tag1", time, {"foo" => "1", "bar" => 'st"r'}
-    d.expect_emit "tag2", time, {"foo" => "2", "bar" => 'str'}
+    expected = [
+      ["tag1", time, {"foo" => "1", "bar" => 'st"r'}],
+      ["tag2", time, {"foo" => "2", "bar" => 'str'}],
+    ]
 
     d.run do
-      d.expected_emits.each { |tag, time, record|
+      expected.each do |tag, time, record|
         body = record.map { |k, v| v }.to_csv
         res = post("/#{tag}?time=#{time.to_s}", body)
         assert_equal "200", res.code
-      }
+      end
     end
+
+    assert_equal expected[0], d.emits[0]
+    assert_equal expected[1], d.emits[1]
   end
 
   def test_resonse_with_empty_img
@@ -272,54 +301,55 @@ def test_resonse_with_empty_img
 
     time = Fluent::EventTime.new(Time.parse("2011-01-02 13:14:15 UTC").to_i)
 
-    d.expect_emit "tag1", time, {"a"=>1}
-    d.expect_emit "tag2", time, {"a"=>2}
+    expected = [
+      ["tag1", time, {"a"=>1}],
+      ["tag2", time, {"a"=>2}],
+    ]
 
     d.run do
-      d.expected_emits.each {|tag,time,record|
+      expected.each do |tag,time,record|
         res = post("/#{tag}", {"json"=>record.to_json, "time"=>time.to_s})
         assert_equal "200", res.code
         # Ruby returns ASCII-8 encoded string for GIF.
-        assert_equal Fluent::HttpInput::EMPTY_GIF_IMAGE, res.body.force_encoding("UTF-8")
-      }
+        assert_equal Fluent::Plugin::HttpInput::EMPTY_GIF_IMAGE, res.body.force_encoding("UTF-8")
+      end
     end
+
+    assert_equal expected[0], d.emits[0]
+    assert_equal expected[1], d.emits[1]
+  end
+
+  $test_in_http_connection_object_ids = []
+  $test_in_http_content_types = []
+  $test_in_http_content_types_flag = false
+  module ContentTypeHook
+    def on_message_begin
+      super
+      if $test_in_http_content_types_flag
+        $test_in_http_connection_object_ids << @io_handler.object_id
+      end
+    end
+
+    def on_headers_complete(headers)
+      super
+      if $test_in_http_content_types_flag
+        $test_in_http_content_types << self.content_type
+      end
+    end
+  end
+
+  class Fluent::Plugin::HttpInput::HttpParserHandler
+    prepend ContentTypeHook
   end
 
   def test_if_content_type_is_initialized_properly
     # This test is to check if Fluent::HttpInput::Handler's @content_type is initialized properly.
     # Especially when in Keep-Alive and the second request has no 'Content-Type'.
-    #
-    # Actually, in the current implementation of in_http, we can't test it directly.
-    # So we replace Fluent::HttpInput::Handler temporally with the extended Handler
-    # in order to collect @content_type(s) per request.
-    # Finally, we check those collected @content_type(s).
-
-    # Save the original Handler
-    orig_handler = Fluent::HttpInput::Handler
 
     begin
-      # Create the extended Handler which can store @content_type per request
-      ext_handler = Class.new(Fluent::HttpInput::Handler) do
-        @@content_types = []
-
-        def self.content_types
-          @@content_types
-        end
-
-        def on_message_complete
-          @@content_types << @content_type
-          super
-        end
-      end
-
-      # Replace the original Handler temporally with the extended one
-      Fluent::HttpInput.module_eval do
-        remove_const(:Handler) if const_defined?(:Handler)
-        const_set(:Handler, ext_handler)
-      end
-
       d = create_driver
 
+      $test_in_http_content_types_flag = true
       d.run do
         # Send two requests the second one has no Content-Type in Keep-Alive
         Net::HTTP.start("127.0.0.1", PORT) do |http|
@@ -329,16 +359,13 @@ def on_message_complete
           req = Net::HTTP::Get.new("/foodb/bartbl", {"connection" => "keepalive"})
           res = http.request(req)
         end
-
-        assert_equal(['application/json', ''], ext_handler.content_types)
       end
     ensure
-      # Revert the original Handler
-      Fluent::HttpInput.module_eval do
-        remove_const(:Handler) if const_defined?(:Handler)
-        const_set(:Handler, orig_handler)
-      end
+      $test_in_http_content_types_flag = false
     end
+    assert_equal(['application/json', ''], $test_in_http_content_types)
+    # Asserting keepalive
+    assert_equal $test_in_http_connection_object_ids[0], $test_in_http_connection_object_ids[1]
   end
 
   def post(path, params, header = {})
diff --git a/test/plugin/test_in_object_space.rb b/test/plugin/test_in_object_space.rb
index fc370e9529..7a3cc4d2a4 100644
--- a/test/plugin/test_in_object_space.rb
+++ b/test/plugin/test_in_object_space.rb
@@ -1,5 +1,6 @@
 require_relative '../helper'
 require 'fluent/test'
+require 'fluent/plugin/in_object_space'
 
 class ObjectSpaceInputTest < Test::Unit::TestCase
   class FailObject
diff --git a/test/plugin/test_in_stream.rb b/test/plugin/test_in_stream.rb
index 2501832f17..462eb24308 100644
--- a/test/plugin/test_in_stream.rb
+++ b/test/plugin/test_in_stream.rb
@@ -1,5 +1,6 @@
 require_relative '../helper'
 require 'fluent/test'
+require 'fluent/plugin/in_stream'
 
 module StreamInputTest
   def setup
diff --git a/test/plugin/test_in_syslog.rb b/test/plugin/test_in_syslog.rb
index d65c4afd32..3bb9ea6d36 100755
--- a/test/plugin/test_in_syslog.rb
+++ b/test/plugin/test_in_syslog.rb
@@ -1,10 +1,10 @@
 require_relative '../helper'
 require 'fluent/test'
+require 'fluent/plugin/in_syslog'
 
 class SyslogInputTest < Test::Unit::TestCase
   def setup
     Fluent::Test.setup
-    require 'fluent/plugin/socket_util'
   end
 
   PORT = unused_port
@@ -21,7 +21,7 @@ def setup
   ]
 
   def create_driver(conf=CONFIG)
-    Fluent::Test::InputTestDriver.new(Fluent::SyslogInput).configure(conf)
+    Fluent::Test::Driver::Input.new(Fluent::Plugin::SyslogInput).configure(conf)
   end
 
   def test_configure
@@ -47,13 +47,17 @@ def test_time_format
         {'msg' => '<6>Sep  1 00:00:00 localhost logger: foo', 'expected' => Fluent::EventTime.from_time(Time.strptime('Sep  1 00:00:00', '%b  %d %H:%M:%S'))},
       ]
 
+      d.expected_emits_length = 1
       d.run do
-        u = Fluent::SocketUtil.create_udp_socket(k)
+        u = if IPAddr.new(IPSocket.getaddress(k)).ipv4?
+              UDPSocket.new
+            else
+              UDPSocket.new(Socket::AF_INET6)
+            end
         u.connect(k, PORT)
         tests.each {|test|
           u.send(test['msg'], 0)
         }
-        sleep 1
       end
 
       emits = d.emits
@@ -67,13 +71,13 @@ def test_msg_size
     d = create_driver
     tests = create_test_case
 
+    d.expected_emits_length = 1
     d.run do
       u = UDPSocket.new
       u.connect('127.0.0.1', PORT)
       tests.each {|test|
         u.send(test['msg'], 0)
       }
-      sleep 1
     end
 
     compare_test_result(d.emits, tests)
@@ -83,13 +87,13 @@ def test_msg_size_with_tcp
     d = create_driver([CONFIG, 'protocol_type tcp'].join("\n"))
     tests = create_test_case
 
+    d.expected_emits_length = 2
     d.run do
       tests.each {|test|
         TCPSocket.open('127.0.0.1', PORT) do |s|
           s.send(test['msg'], 0)
         end
       }
-      sleep 1
     end
 
     compare_test_result(d.emits, tests)
@@ -99,13 +103,13 @@ def test_msg_size_with_same_tcp_connection
     d = create_driver([CONFIG, 'protocol_type tcp'].join("\n"))
     tests = create_test_case
 
+    d.expected_emits_length = 2
     d.run do
       TCPSocket.open('127.0.0.1', PORT) do |s|
         tests.each {|test|
           s.send(test['msg'], 0)
         }
       end
-      sleep 1
     end
 
     compare_test_result(d.emits, tests)
@@ -119,23 +123,24 @@ def test_msg_size_with_json_format
       {'msg' => '<6>' + event.to_json + "\n", 'expected' => msg}
     }
 
+    d.expected_emits_length = 2
     d.run do
       u = UDPSocket.new
       u.connect('127.0.0.1', PORT)
       tests.each {|test|
         u.send(test['msg'], 0)
       }
-      sleep 1
     end
 
     compare_test_result(d.emits, tests)
   end
 
   def test_msg_size_with_include_source_host
-    d = create_driver([CONFIG, 'include_source_host'].join("\n"))
+    d = create_driver([CONFIG, 'include_source_host yes'].join("\n"))
     tests = create_test_case
 
     host = nil
+    d.expected_emits_length = 2
     d.run do
       u = UDPSocket.new
       u.connect('127.0.0.1', PORT)
@@ -143,7 +148,6 @@ def test_msg_size_with_include_source_host
       tests.each {|test|
         u.send(test['msg'], 0)
       }
-      sleep 1
     end
 
     compare_test_result(d.emits, tests, host)
diff --git a/test/plugin/test_in_tail.rb b/test/plugin/test_in_tail.rb
index 21f40ff7b2..30dc15165f 100644
--- a/test/plugin/test_in_tail.rb
+++ b/test/plugin/test_in_tail.rb
@@ -2,6 +2,7 @@
 require 'fluent/test'
 require 'net/http'
 require 'flexmock'
+require 'fluent/plugin/in_tail'
 
 class TailInputTest < Test::Unit::TestCase
   include FlexMock::TestCase
diff --git a/test/plugin/test_in_tcp.rb b/test/plugin/test_in_tcp.rb
index 0b89da8c9e..e0f24563a3 100755
--- a/test/plugin/test_in_tcp.rb
+++ b/test/plugin/test_in_tcp.rb
@@ -1,5 +1,6 @@
 require_relative '../helper'
 require 'fluent/test'
+require 'fluent/plugin/in_tcp'
 
 class TcpInputTest < Test::Unit::TestCase
   def setup
@@ -21,7 +22,7 @@ def setup
   ]
 
   def create_driver(conf)
-    Fluent::Test::InputTestDriver.new(Fluent::TcpInput).configure(conf)
+    Fluent::Test::Driver::Input.new(Fluent::Plugin::TcpInput).configure(conf)
   end
 
   def test_configure
diff --git a/test/plugin/test_in_udp.rb b/test/plugin/test_in_udp.rb
index 1d4d46284f..bcc1eb5851 100755
--- a/test/plugin/test_in_udp.rb
+++ b/test/plugin/test_in_udp.rb
@@ -1,5 +1,7 @@
 require_relative '../helper'
 require 'fluent/test'
+require 'fluent/plugin/in_udp'
+require 'fluent/plugin/socket_util'
 
 class UdpInputTest < Test::Unit::TestCase
   def setup
@@ -21,7 +23,7 @@ def setup
   !
 
   def create_driver(conf)
-    Fluent::Test::InputTestDriver.new(Fluent::UdpInput).configure(conf)
+    Fluent::Test::Driver::Input.new(Fluent::Plugin::UdpInput).configure(conf)
   end
 
   def test_configure
diff --git a/test/plugin/test_out_copy.rb b/test/plugin/test_out_copy.rb
index 04725d198c..52c947d4b0 100644
--- a/test/plugin/test_out_copy.rb
+++ b/test/plugin/test_out_copy.rb
@@ -1,5 +1,6 @@
 require_relative '../helper'
 require 'fluent/test'
+require 'fluent/plugin/out_copy'
 
 class CopyOutputTest < Test::Unit::TestCase
   class << self
diff --git a/test/plugin/test_out_exec.rb b/test/plugin/test_out_exec.rb
index 3b8a8a25af..f76f223197 100644
--- a/test/plugin/test_out_exec.rb
+++ b/test/plugin/test_out_exec.rb
@@ -1,6 +1,7 @@
 require_relative '../helper'
 require 'fluent/test'
 require 'fileutils'
+require 'fluent/plugin/out_exec'
 
 class ExecOutputTest < Test::Unit::TestCase
   def setup
diff --git a/test/plugin/test_out_exec_filter.rb b/test/plugin/test_out_exec_filter.rb
index 00d888dd5c..2a7b72a6e2 100644
--- a/test/plugin/test_out_exec_filter.rb
+++ b/test/plugin/test_out_exec_filter.rb
@@ -1,6 +1,7 @@
 require_relative '../helper'
 require 'fluent/test'
 require 'fileutils'
+require 'fluent/plugin/out_exec_filter'
 
 class ExecFilterOutputTest < Test::Unit::TestCase
   def setup
diff --git a/test/plugin/test_out_file.rb b/test/plugin/test_out_file.rb
index daa50fc5da..6a05c99c28 100644
--- a/test/plugin/test_out_file.rb
+++ b/test/plugin/test_out_file.rb
@@ -2,6 +2,7 @@
 require 'fluent/test'
 require 'fileutils'
 require 'time'
+require 'fluent/plugin/out_file'
 
 class FileOutputTest < Test::Unit::TestCase
   def setup
diff --git a/test/plugin/test_out_forward.rb b/test/plugin/test_out_forward.rb
index b3f60bd06a..cd29172b98 100644
--- a/test/plugin/test_out_forward.rb
+++ b/test/plugin/test_out_forward.rb
@@ -1,5 +1,6 @@
 require_relative '../helper'
 require 'fluent/test'
+require 'fluent/plugin/out_forward'
 
 class ForwardOutputTest < Test::Unit::TestCase
   def setup
@@ -7,7 +8,7 @@ def setup
   end
 
   TARGET_HOST = '127.0.0.1'
-  TARGET_PORT = 13999
+  TARGET_PORT = unused_port
   CONFIG = %[
     send_timeout 51
     heartbeat_type udp
@@ -58,7 +59,7 @@ def test_configure
     node = nodes.first
     assert_equal "test", node.name
     assert_equal '127.0.0.1', node.host
-    assert_equal 13999, node.port
+    assert_equal TARGET_PORT, node.port
   end
 
   def test_configure_udp_heartbeat
@@ -189,9 +190,11 @@ def test_send_without_time_as_integer
   end
 
   def test_send_to_a_node_supporting_responses
-    target_input_driver = create_target_input_driver(true)
+    target_input_driver = create_target_input_driver # default in_forward supports responses
+    target_input_driver.expected_emits_length = 2
+    target_input_driver.run_timeout = 3
 
-    d = create_driver(CONFIG + %[flush_interval 1s])
+    d = create_driver(CONFIG + %[flush_interval 0s])
 
     time = Time.parse("2011-01-02 13:14:15 UTC").to_i
 
@@ -200,7 +203,7 @@ def test_send_to_a_node_supporting_responses
       {"a" => 2}
     ]
     d.register_run_post_condition do
-      d.instance.responses.length == 1
+      d.instance.responses.length > 0
     end
 
     target_input_driver.run do
@@ -220,7 +223,7 @@ def test_send_to_a_node_supporting_responses
   end
 
   def test_send_to_a_node_not_supporting_responses
-    target_input_driver = create_target_input_driver
+    target_input_driver = create_target_input_driver(->(options){ nil })
 
     d = create_driver(CONFIG + %[flush_interval 1s])
 
@@ -251,7 +254,7 @@ def test_send_to_a_node_not_supporting_responses
   end
 
   def test_require_a_node_supporting_responses_to_respond_with_ack
-    target_input_driver = create_target_input_driver(true)
+    target_input_driver = create_target_input_driver()
 
     d = create_driver(CONFIG + %[
       flush_interval 1s
@@ -288,7 +291,9 @@ def test_require_a_node_supporting_responses_to_respond_with_ack
 
   def test_require_a_node_not_supporting_responses_to_respond_with_ack
     # in_forward, that doesn't support ack feature, and keep connection alive
-    target_input_driver = create_target_input_driver
+    target_input_driver = create_target_input_driver(->(options){ sleep 5 })
+    target_input_driver.expected_emits_length = 2
+    target_input_driver.run_timeout = 5
 
     d = create_driver(CONFIG + %[
       flush_interval 1s
@@ -329,7 +334,7 @@ def test_require_a_node_not_supporting_responses_to_respond_with_ack
   # bdf1f4f104c00a791aa94dc20087fe2011e1fd83
   def test_require_a_node_not_supporting_responses_2_to_respond_with_ack
     # in_forward, that doesn't support ack feature, and disconnect immediately
-    target_input_driver = create_target_input_driver(false, true)
+    target_input_driver = create_target_input_driver(nil, true)
 
     d = create_driver(CONFIG + %[
       flush_interval 1s
@@ -367,129 +372,19 @@ def test_require_a_node_not_supporting_responses_2_to_respond_with_ack
     assert_equal false, node.available # node is regarded as unavailable when unexpected EOF
   end
 
-  def create_target_input_driver(do_respond=false, disconnect=false, conf=TARGET_CONFIG)
+  ## TODO: check this works well or not...
+  def create_target_input_driver(response_stub=nil, disconnect=false, conf=TARGET_CONFIG)
+    ## TODO: disconnect
     require 'fluent/plugin/in_forward'
 
-    # TODO: Support actual TCP heartbeat test
-    DummyEngineDriver.new(Fluent::ForwardInput) {
-      handler_class = Class.new(Fluent::ForwardInput::Handler) { |klass|
-        attr_reader :chunk_counter # for checking if received data is successfully deserialized
-
-        def initialize(sock, log, on_message)
-          @sock = sock
-          @log = log
-          @chunk_counter = 0
-          @on_message = on_message
-        end
-
-        if do_respond
-          def write(data)
-            @sock.write data
-          rescue => e
-            @sock.close_write
-            @sock.close
-          end
-        else
-          def write(data)
-            # do nothing
-          end
-        end
-
-        def close
-          @sock.close_write
-          @sock.close
-        end
-      }
-
-      define_method(:start) do
-        @thread = Thread.new do
-          Socket.tcp_server_loop(@host, @port) do |sock, client_addrinfo|
-            begin
-              handler = handler_class.new(sock, @log, method(:on_message))
-              loop do
-                raw_data = sock.recv(1024)
-                handler.on_read(raw_data)
-                # chunk_counter is reset to zero only after all the data have been received and successfully deserialized.
-                break if handler.chunk_counter == 0
-              end
-              if disconnect
-                handler.close
-                sock = nil
-              end
-              sleep  # wait for connection to be closed by client
-            ensure
-              if sock
-                sock.close_write
-                sock.close
-              end
-            end
-          end
+    Fluent::Test::Driver::Input.new(Fluent::Plugin::ForwardInput) {
+      if response_stub.nil?
+        # do nothing because in_forward responds for ack option in default
+      else
+        define_method(:response) do |options|
+          return response_stub.(options)
         end
       end
-
-      def shutdown
-        @thread.kill
-        @thread.join
-      end
-    }.configure(conf).inject_router()
-  end
-
-  def test_heartbeat_type_none
-    d = create_driver(CONFIG + "\nheartbeat_type none")
-    node = d.instance.nodes.first
-    assert_equal Fluent::ForwardOutput::NoneHeartbeatNode, node.class
-
-    d.instance.start
-    assert_nil d.instance.instance_variable_get(:@loop)   # no HeartbeatHandler, or HeartbeatRequestTimer
-    assert_nil d.instance.instance_variable_get(:@thread) # no HeartbeatHandler, or HeartbeatRequestTimer
-
-    stub(node.failure).phi { raise 'Should not be called' }
-    node.tick
-    assert_equal node.available, true
-  end
-
-  class DummyEngineDriver < Fluent::Test::TestDriver
-    def initialize(klass, &block)
-      super(klass, &block)
-      @engine = DummyEngineClass.new
-      @klass = klass
-      # To avoid accessing Fluent::Engine, set Engine as a plugin's class constant (Fluent::SomePlugin::Engine).
-      # But this makes it impossible to run tests concurrently by threading in a process.
-      @klass.const_set(:Engine, @engine)
-    end
-
-    def inject_router
-      @instance.router = @engine
-      self
-    end
-
-    def run(&block)
-      super(&block)
-      @klass.class_eval do
-        remove_const(:Engine)
-      end
-    end
-
-    def emits
-      all = []
-      @engine.emit_streams.each {|tag,events|
-        events.each {|time,record|
-          all << [tag, time, record]
-        }
-      }
-      all
-    end
-
-    class DummyEngineClass
-      attr_reader :emit_streams
-
-      def initialize
-        @emit_streams ||= []
-      end
-
-      def emit_stream(tag, es)
-        @emit_streams << [tag, es.to_a]
-      end
-    end
+    }.configure(conf)
   end
 end
diff --git a/test/plugin/test_out_roundrobin.rb b/test/plugin/test_out_roundrobin.rb
index 76c87460ab..56722f0174 100644
--- a/test/plugin/test_out_roundrobin.rb
+++ b/test/plugin/test_out_roundrobin.rb
@@ -1,5 +1,6 @@
 require_relative '../helper'
 require 'fluent/test'
+require 'fluent/plugin/out_roundrobin'
 
 class RoundRobinOutputTest < Test::Unit::TestCase
   class << self
diff --git a/test/plugin/test_out_stdout.rb b/test/plugin/test_out_stdout.rb
index ba07c33083..49e0567057 100644
--- a/test/plugin/test_out_stdout.rb
+++ b/test/plugin/test_out_stdout.rb
@@ -1,5 +1,6 @@
 require_relative '../helper'
 require 'fluent/test'
+require 'fluent/plugin/out_stdout'
 
 class StdoutOutputTest < Test::Unit::TestCase
   def setup
diff --git a/test/plugin/test_out_stream.rb b/test/plugin/test_out_stream.rb
index b105411a5c..f79d51cf86 100644
--- a/test/plugin/test_out_stream.rb
+++ b/test/plugin/test_out_stream.rb
@@ -1,5 +1,6 @@
 require_relative '../helper'
 require 'fluent/test'
+require 'fluent/plugin/out_stream'
 
 module StreamOutputTest
   def setup
diff --git a/test/storage/test_json.rb b/test/storage/test_json.rb
new file mode 100644
index 0000000000..0a2fb8c311
--- /dev/null
+++ b/test/storage/test_json.rb
@@ -0,0 +1,123 @@
+require_relative '../helper'
+require 'fluent/test'
+require 'fluent/storage/json'
+
+require 'fileutils'
+
+module Fluent::Storage
+  class JSONStorageTest < Test::Unit::TestCase
+    sub_test_case Fluent::Storage::JSON do
+      setup do
+        @storage_path = File.join(File.dirname(File.dirname(__FILE__)), 'tmp', 'storage')
+        FileUtils.rm_rf(@storage_path, secure: true) if Dir.exist?(@storage_path)
+        FileUtils.mkdir_p(@storage_path)
+
+        @storage = Fluent::Storage::JSON.new
+      end
+
+      sub_test_case '#put' do
+        test "#put handle keys both symbols and strings as same" do
+          obj = "data1"
+          @storage.put(:key1, obj)
+          assert_equal obj.object_id, @storage.instance_eval{ @store[:key1] }.object_id
+
+          @storage.put("key1", obj)
+          assert_equal obj.object_id, @storage.instance_eval{ @store[:key1] }.object_id
+        end
+      end
+
+      sub_test_case '#get' do
+        test "return nil for unknown keys" do
+          assert_nil @storage.get(:key1)
+
+          @storage.put(:key1, "data1")
+          assert_equal "data1", @storage.get(:key1)
+
+          assert_nil @storage.get(:key2)
+        end
+
+        test "get handle keys both symbols and strings as same" do
+          obj = "data1"
+          @storage.put(:key1, obj)
+          assert_equal obj.object_id, @storage.get(:key1).object_id
+          assert_equal obj.object_id, @storage.get("key1").object_id
+
+          obj = "data2"
+          @storage.put("key1", obj)
+          assert_equal obj.object_id, @storage.get(:key1).object_id
+          assert_equal obj.object_id, @storage.get("key1").object_id
+        end
+      end
+
+      sub_test_case '#fetch' do
+        test "fetch works as well as Hash#fetch" do
+          assert_equal "data", @storage.fetch(:key1, "data")
+
+          @storage.put(:key1, "data1")
+          assert_equal "data1", @storage.fetch(:key1, "data")
+        end
+      end
+
+      def e(name, arg = '', attrs = {}, elements = [])
+        attrs_str_keys = {}
+        attrs.each{|key, value| attrs_str_keys[key.to_s] = value }
+        Fluent::Config::Element.new(name, arg, attrs_str_keys, elements)
+      end
+
+      sub_test_case '#save' do
+        test "stored data is saved as plain-text JSON data on the disk" do
+          test_path = File.join(@storage_path, 'save_test_1.json')
+          assert !(File.exist?(test_path))
+
+          @storage.configure(e('ROOT', '', {}, [e('storage', '', {'path' => test_path, 'pretty_print' => 'false'}, [])]))
+          assert_equal test_path, @storage.storage_config.path
+          assert_equal test_path + '.tmp', @storage.instance_eval{ @tmp_path }
+          assert_equal false, @storage.storage_config.pretty_print
+
+          assert_equal({}, @storage.instance_eval{ @store })
+
+          t = Time.now
+
+          @storage.put(:key1, 'data1')
+          @storage.put(:key2, {k1: 'v1', k2: 'v2', k3: [1,2,3]})
+          @storage.put(:key3, ['a', 'b', 'c', 'd'])
+          @storage.put(:key4, t.to_i)
+
+          @storage.save
+
+          assert !(File.exist?(test_path + '.tmp'))
+          assert File.exist?(test_path)
+
+          content = open(test_path){|f| ::JSON.parse(f.read, symbolize_names: true)}
+          expected = {key1: 'data1', key2: {k1: 'v1', k2: 'v2', k3: [1,2,3]}, key3: ['a', 'b', 'c', 'd'], key4: t.to_i}
+          assert_equal expected, content
+        end
+      end
+
+      sub_test_case '#load' do
+        test "saved data is successfully loaded with symbolized keys" do
+          test_path = File.join(@storage_path, 'load_test_1.json')
+          assert !(File.exist?(test_path))
+
+          t = Time.now
+
+          expected = {key1: 'data1', key2: {k1: 'v1', k2: 'v2', k3: [1,2,3]}, key3: ['a', 'b', 'c', 'd'], key4: t.to_i}
+          open(test_path, 'w:utf-8') do |f|
+            f.write expected.to_json
+          end
+          assert File.exist?(test_path)
+
+          @storage.configure(e('ROOT', '', {}, [e('storage', '', {'path' => test_path, 'pretty_print' => 'false'}, [])]))
+          @storage.load
+
+          assert_equal expected, @storage.instance_eval{ @store }
+
+          assert_equal 'data1', @storage.get(:key1)
+          assert_equal({k1: 'v1', k2: 'v2', k3: [1,2,3]}, @storage.get(:key2))
+          assert_equal ['a', 'b', 'c', 'd'], @storage.get(:key3)
+          assert_equal t.to_i, @storage.get(:key4)
+        end
+      end
+    end
+  end
+end