fluentd 1.17.1-x64-mingw-ucrt → 1.19.0-x64-mingw-ucrt

data/lib/fluent/plugin/parser.rb

@@ -29,7 +29,7 @@ module Fluent
     class Parser < Base
       class TimeoutChecker
         # This implementation now uses mutex because parser is typically used in input.
-        # If this has a performance issue under high concurreny, use concurrent-ruby's map instead.
+        # If this has a performance issue under high concurrent, use concurrent-ruby's map instead.
         def initialize(timeout)
           @map = {}
           @flag = ServerEngine::BlockingFlag.new
@@ -46,8 +46,8 @@ module Fluent
                 @map.keys.each { |th|
                   time = @map[th]
                   if now - time > @timeout
-                    th.raise UncatchableError, "parsing timed out"
                     @map.delete(th)
+                    th.raise UncatchableError, "parsing timed out"
                   end
                 }
               }
@@ -220,7 +220,7 @@ module Fluent
       end
 
       def string_like_null(value, null_empty_string = @null_empty_string, null_value_regexp = @null_value_pattern)
-        null_empty_string && value.empty? || null_value_regexp && string_safe_encoding(value){|s| null_value_regexp.match(s) }
+        null_empty_string && value.empty? || null_value_regexp && string_safe_encoding(value){|s| null_value_regexp.match?(s) }
       end
 
       TRUTHY_VALUES = ['true', 'yes', '1']

data/lib/fluent/plugin/parser_json.rb

@@ -52,9 +52,9 @@ module Fluent
         when :oj
           return [Oj.method(:load), Oj::ParseError] if Fluent::OjOptions.available?
 
-          log&.info "Oj is not installed, and failing back to Yajl for json parser"
-          configure_json_parser(:yajl)
-        when :json then [JSON.method(:load), JSON::ParserError]
+          log&.info "Oj is not installed, and failing back to JSON for json parser"
+          configure_json_parser(:json)
+        when :json then [JSON.method(:parse), JSON::ParserError]
         when :yajl then [Yajl.method(:load), Yajl::ParseError]
         else
           raise "BUG: unknown json parser specified: #{name}"

data/lib/fluent/plugin/sd_file.rb

@@ -27,7 +27,7 @@ module Fluent
       Plugin.register_sd('file', self)
 
       DEFAULT_FILE_TYPE = :yaml
-      DEFAUT_WEIGHT = 60
+      DEFAULT_WEIGHT = 60
       DEFAULT_SD_FILE_PATH = ENV['DEFAULT_SD_FILE_PATH'] || '/etc/fluent/sd.yaml'
 
       helpers :event_loop
@@ -126,7 +126,7 @@ module Fluent
             s.fetch('host'),
             s.fetch('port'),
             s['name'],
-            s.fetch('weight', DEFAUT_WEIGHT),
+            s.fetch('weight', DEFAULT_WEIGHT),
             s['standby'],
             s['username'],
             s['password'],

data/lib/fluent/plugin/storage_local.rb

@@ -19,7 +19,7 @@ require 'fluent/plugin'
 require 'fluent/plugin/storage'
 
 require 'fileutils'
-require 'yajl'
+require 'json'
 
 module Fluent
   module Plugin
@@ -90,7 +90,7 @@ module Fluent
                 log.warn "detect empty plugin storage file during startup. Ignored: #{@path}"
                 return
               end
-              data = Yajl::Parser.parse(data)
+              data = JSON.parse(data)
               raise Fluent::ConfigError, "Invalid contents (not object) in plugin storage file: '#{@path}'" unless data.is_a?(Hash)
             rescue => e
               log.error "failed to read data from plugin storage file", path: @path, error: e
@@ -114,7 +114,7 @@ module Fluent
         return unless File.exist?(@path)
         begin
           json_string = File.open(@path, 'r:utf-8'){ |io| io.read }
-          json = Yajl::Parser.parse(json_string)
+          json = JSON.parse(json_string)
           unless json.is_a?(Hash)
             log.error "broken content for plugin storage (Hash required: ignored)", type: json.class
             log.debug "broken content", content: json_string
@@ -130,7 +130,11 @@ module Fluent
         return if @on_memory
         tmp_path = @path + '.tmp.' + Fluent::UniqueId.hex(Fluent::UniqueId.generate)
         begin
-          json_string = Yajl::Encoder.encode(@store, pretty: @pretty_print)
+          if @pretty_print
+            json_string = JSON.pretty_generate(@store)
+          else
+            json_string = JSON.generate(@store)
+          end
           File.open(tmp_path, 'w:utf-8', @mode) { |io| io.write json_string; io.fsync }
           File.rename(tmp_path, @path)
         rescue => e

data/lib/fluent/plugin.rb

@@ -175,7 +175,7 @@ module Fluent
              else
                raise Fluent::ConfigError, "#{kind} plugin '#{type}' is not a Class nor callable (without arguments)."
              end
-      if parent && impl.respond_to?("owner=")
+      if parent && impl.respond_to?(:owner=)
         impl.owner = parent
       end
       impl.extend FeatureAvailabilityChecker

data/lib/fluent/plugin_helper/cert_option.rb

@@ -33,6 +33,14 @@ module Fluent
 
         if conf.client_cert_auth
           ctx.verify_mode = OpenSSL::SSL::VERIFY_PEER | OpenSSL::SSL::VERIFY_FAIL_IF_NO_PEER_CERT
+        else
+          ctx.verify_mode = OpenSSL::SSL::VERIFY_NONE
+        end
+
+        if conf.ensure_fips
+          unless OpenSSL.fips_mode
+            raise Fluent::ConfigError, "Cannot enable FIPS compliant mode. OpenSSL FIPS configuration is disabled"
+          end
         end
 
         ctx.ca_file = conf.ca_path

data/lib/fluent/plugin_helper/child_process.rb

@@ -143,7 +143,7 @@ module Fluent
         @_child_process_mutex.synchronize{ @_child_process_processes.keys }.each do |pid|
           process_info = @_child_process_processes[pid]
           next if !process_info
-          process_info.writeio && process_info.writeio.close rescue nil
+          process_info.writeio&.close rescue nil
         end
 
         super
@@ -183,7 +183,7 @@ module Fluent
 
             living_process_exist = true
 
-            process_info.killed_at ||= Fluent::Clock.now # for illegular case (e.g., created after shutdown)
+            process_info.killed_at ||= Fluent::Clock.now # for irregular case (e.g., created after shutdown)
             timeout_at = process_info.killed_at + @_child_process_kill_timeout
             now = Fluent::Clock.now
             next if now < timeout_at

data/lib/fluent/plugin_helper/event_emitter.rb

@@ -26,6 +26,9 @@ module Fluent
 
       def router
         @_event_emitter_used_actually = true
+
+        return Engine.root_agent.source_only_router if @_event_emitter_force_source_only_router
+
         if @_event_emitter_lazy_init
           @router = @primary_instance.router
         end
@@ -48,6 +51,14 @@ module Fluent
         @_event_emitter_used_actually
       end
 
+      def event_emitter_apply_source_only
+        @_event_emitter_force_source_only_router = true
+      end
+
+      def event_emitter_cancel_source_only
+        @_event_emitter_force_source_only_router = false
+      end
+
       def event_emitter_router(label_name)
         if label_name
           if label_name == "@ROOT"
@@ -72,6 +83,7 @@ module Fluent
         super
         @_event_emitter_used_actually = false
         @_event_emitter_lazy_init = false
+        @_event_emitter_force_source_only_router = false
         @router = nil
       end
 

data/lib/fluent/plugin_helper/http_server/request.rb

@@ -14,6 +14,7 @@
 #    limitations under the License.
 #
 
+require 'uri'
 require 'async/http/protocol'
 require 'fluent/plugin_helper/http_server/methods'
 
@@ -29,12 +30,22 @@ module Fluent
           @path, @query_string = path.split('?', 2)
         end
 
+        def headers
+          @request.headers
+        end
+
         def query
-          @query_string && CGI.parse(@query_string)
+          if @query_string
+            hash = Hash.new { |h, k| h[k] = [] }
+            # For compatibility with CGI.parse
+            URI.decode_www_form(@query_string).each_with_object(hash) do |(key, value), h|
+              h[key] << value
+            end
+          end
         end
 
         def body
-          @request.body && @request.body.read
+          @request.body&.read
         end
       end
     end

data/lib/fluent/plugin_helper/http_server/server.rb

@@ -39,7 +39,8 @@ module Fluent
           scheme = tls_context ? 'https' : 'http'
           @uri = URI("#{scheme}://#{@addr}:#{@port}").to_s
           @router = Router.new(default_app)
-          @reactor = Async::Reactor.new(nil, logger: Fluent::Log::ConsoleAdapter.wrap(@logger))
+          @server_task = nil
+          Console.logger = Fluent::Log::ConsoleAdapter.wrap(@logger)
 
           opts = if tls_context
                    { ssl_context: tls_context }
@@ -54,25 +55,30 @@ module Fluent
         end
 
         def start(notify = nil)
+          Console.logger = Fluent::Log::ConsoleAdapter.wrap(@logger)
           @logger.debug("Start async HTTP server listening #{@uri}")
-          task = @reactor.run do
-            @server.run
 
+          Async do |task|
+            Console.logger = Fluent::Log::ConsoleAdapter.wrap(@logger)
+            @server_task = task.async do
+              Console.logger = Fluent::Log::ConsoleAdapter.wrap(@logger)
+              @server.run
+            end
             if notify
               notify.push(:ready)
             end
+
+            @server_task_queue = ::Thread::Queue.new
+            @server_task_queue.pop
+            @server_task&.stop
           end
 
-          task.stop
           @logger.debug('Finished HTTP server')
         end
 
         def stop
           @logger.debug('closing HTTP server')
-
-          if @reactor
-            @reactor.stop
-          end
+          @server_task_queue.push(:stop)
         end
 
         HttpServer::Methods::ALL.map { |e| e.downcase.to_sym }.each do |name|

data/lib/fluent/plugin_helper/http_server.rb

@@ -14,16 +14,9 @@
 #    limitations under the License.
 #
 
-begin
-  require 'async'
-  require 'fluent/plugin_helper/http_server/server'
-rescue LoadError => _
-  require 'fluent/plugin_helper/http_server/compat/server'
-  Fluent::PluginHelper::HttpServer::Server = Fluent::PluginHelper::HttpServer::Compat::Server
-end
-
 require 'fluent/plugin_helper/thread'
 require 'fluent/plugin_helper/server' # For Server::ServerTransportParams
+require 'fluent/plugin_helper/http_server/server'
 require 'fluent/plugin_helper/http_server/ssl_context_builder'
 
 module Fluent

data/lib/fluent/plugin_helper/metrics.rb

@@ -72,6 +72,13 @@ module Fluent
 
         @_metrics["#{@plugin_type_or_id}_#{namespace}_#{subsystem}_#{name}"] = metrics
 
+        # define the getter method for the calling instance.
+        singleton_class.module_eval do
+          unless method_defined?(name)
+            define_method(name) { metrics.get }
+          end
+        end
+
         metrics
       end
 

data/lib/fluent/plugin_helper/server.rb

@@ -84,6 +84,8 @@ module Fluent
           socket_options[:linger_timeout] ||= @transport_config&.linger_timeout || 0
         end
 
+        socket_options[:receive_buffer_size] ||= @transport_config&.receive_buffer_size
+
         socket_option_validate!(proto, **socket_options)
         socket_option_setter = ->(sock){ socket_option_set(sock, **socket_options) }
 
@@ -136,6 +138,8 @@ module Fluent
           socket_options[:linger_timeout] ||= @transport_config&.linger_timeout || 0
         end
 
+        socket_options[:receive_buffer_size] ||= @transport_config&.receive_buffer_size
+
         unless socket
           socket_option_validate!(proto, **socket_options)
           socket_option_setter = ->(sock){ socket_option_set(sock, **socket_options) }
@@ -247,6 +251,7 @@ module Fluent
         :generate_cert_country, :generate_cert_state, :generate_cert_state,
         :generate_cert_locality, :generate_cert_common_name,
         :generate_cert_expiration, :generate_cert_digest,
+        :ensure_fips,
       ]
 
       def server_create_transport_section_object(opts)
@@ -266,6 +271,9 @@ module Fluent
 
           ### Socket Params ###
 
+          desc "The max size of socket receive buffer. SO_RCVBUF"
+          config_param :receive_buffer_size, :size, default: nil
+
           # SO_LINGER 0 to send RST rather than FIN to avoid lots of connections sitting in TIME_WAIT at src.
           # Set positive value if needing to send FIN on closing on non-Windows.
           # (On Windows, Fluentd can send FIN with zero `linger_timeout` since Fluentd doesn't set 0 to SO_LINGER on Windows.
@@ -287,6 +295,7 @@ module Fluent
           config_param :max_version, :enum, list: Fluent::TLS::SUPPORTED_VERSIONS, default: nil
           config_param :ciphers, :string, default: Fluent::TLS::CIPHERS_DEFAULT
           config_param :insecure, :bool, default: false
+          config_param :ensure_fips, :bool, default: false
 
           # Cert signed by public CA
           config_param :ca_path, :string, default: nil
@@ -347,7 +356,10 @@ module Fluent
       end
 
       def shutdown
-        @_server_connections.each do |conn|
+        # When it invokes conn.cose, it reduces elements in @_server_connections by close_callback,
+        # and it reduces the number of loops. This prevents the connection closing.
+        # So, it requires invoking #dup to avoid the problem.
+        @_server_connections.dup.each do |conn|
           conn.close rescue nil
         end
 

data/lib/fluent/plugin_helper/service_discovery.rb

@@ -91,7 +91,7 @@ module Fluent
       end
 
       # @param title [Symbol] the thread name. this value should be unique.
-      # @param configurations [Hash] hash which must has discivery_service type and its configuration like `{ type: :static, conf: <Fluent::Config::Element> }`
+      # @param configurations [Hash] hash which must has discovery_service type and its configuration like `{ type: :static, conf: <Fluent::Config::Element> }`
       # @param load_balancer [Object] object which has two methods #rebalance and #select_service
       # @param custom_build_method [Proc]
       def service_discovery_create_manager(title, configurations:, load_balancer: nil, custom_build_method: nil, interval: 3)

data/lib/fluent/plugin_helper/socket_option.rb

@@ -54,8 +54,8 @@ module Fluent
         if Fluent.windows?
           # To prevent closing socket forcibly on Windows,
           # this options shouldn't be set up when linger_timeout equals to 0 (including nil).
-          # This unintended behavior always ocurrs on Windows when linger_timeout.to_i == 0.
-          # This unintented behavior causes "Errno::ECONNRESET: An existing connection was forcibly
+          # This unintended behavior always occurs on Windows when linger_timeout.to_i == 0.
+          # This unintended behavior causes "Errno::ECONNRESET: An existing connection was forcibly
           # closed by the remote host." on Windows.
           if linger_timeout.to_i > 0
             if linger_timeout >= 2**16

data/lib/fluent/plugin_helper/storage.rb

@@ -38,7 +38,7 @@ module Fluent
         end
 
         s = @_storages[usage]
-        if s && s.running
+        if s&.running
           return s.storage
         elsif s
           # storage is already created, but not loaded / started

data/lib/fluent/plugin_id.rb

@@ -30,7 +30,7 @@ module Fluent
     end
 
     def configure(conf)
-      @_plugin_id_variable_store = Fluent::VariableStore.fetch_or_build(:pluing_id, default_value: Set.new)
+      @_plugin_id_variable_store = Fluent::VariableStore.fetch_or_build(:plugin_id, default_value: Set.new)
       @id = conf['@id']
       @_id_configured = !!@id # plugin id is explicitly configured by users (or not)
       if @id
@@ -57,13 +57,13 @@ module Fluent
     end
 
     def plugin_id_configured?
-      if instance_variable_defined?("@_id_configured")
+      if instance_variable_defined?(:@_id_configured)
         @_id_configured
       end
     end
 
     def plugin_id
-      if instance_variable_defined?("@id")
+      if instance_variable_defined?(:@id)
         @id || "object:#{object_id.to_s(16)}"
       else
         "object:#{object_id.to_s(16)}"

data/lib/fluent/root_agent.rb

@@ -22,6 +22,7 @@ require 'fluent/label'
 require 'fluent/plugin'
 require 'fluent/system_config'
 require 'fluent/time'
+require 'fluent/source_only_buffer_agent'
 
 module Fluent
   #
@@ -47,28 +48,62 @@ module Fluent
   class RootAgent < Agent
     ERROR_LABEL = "@ERROR".freeze # @ERROR is built-in error label
 
-    def initialize(log:, system_config: SystemConfig.new)
+    class SourceOnlyMode
+      DISABLED = 0
+      NORMAL = 1
+      ONLY_ZERO_DOWNTIME_RESTART_READY = 2
+
+      def initialize(with_source_only, start_in_parallel)
+        if start_in_parallel
+          @mode = ONLY_ZERO_DOWNTIME_RESTART_READY
+        elsif with_source_only
+          @mode = NORMAL
+        else
+          @mode = DISABLED
+        end
+      end
+
+      def enabled?
+        @mode != DISABLED
+      end
+
+      def only_zero_downtime_restart_ready?
+        @mode == ONLY_ZERO_DOWNTIME_RESTART_READY
+      end
+
+      def disable!
+        @mode = DISABLED
+      end
+    end
+
+    def initialize(log:, system_config: SystemConfig.new, start_in_parallel: false)
       super(log: log)
 
       @labels = {}
       @inputs = []
       @suppress_emit_error_log_interval = 0
       @next_emit_error_log_time = nil
-      @without_source = false
-      @enable_input_metrics = false
+      @without_source = system_config.without_source || false
+      @source_only_mode = SourceOnlyMode.new(system_config.with_source_only, start_in_parallel)
+      @source_only_buffer_agent = nil
+      @enable_input_metrics = system_config.enable_input_metrics
 
       suppress_interval(system_config.emit_error_log_interval) unless system_config.emit_error_log_interval.nil?
-      @without_source = system_config.without_source unless system_config.without_source.nil?
-      @enable_input_metrics = !!system_config.enable_input_metrics
     end
 
     attr_reader :inputs
     attr_reader :labels
 
+    def source_only_router
+      raise "[BUG] 'RootAgent#source_only_router' should not be called when 'with_source_only' is false" unless @source_only_mode.enabled?
+      @source_only_buffer_agent.event_router
+    end
+
     def configure(conf)
       used_worker_ids = []
       available_worker_ids = (0..Fluent::Engine.system_config.workers - 1).to_a
       # initialize <worker> elements
+      supported_directives = ['source', 'match', 'filter', 'label']
       conf.elements(name: 'worker').each do |e|
         target_worker_id_str = e.arg
         if target_worker_id_str.empty?
@@ -97,7 +132,7 @@ module Fluent
             used_worker_ids << target_worker_id
 
             e.elements.each do |elem|
-              unless ['source', 'match', 'filter', 'label'].include?(elem.name)
+              unless supported_directives.include?(elem.name)
                 raise Fluent::ConfigError, "<worker> section cannot have <#{elem.name}> directive"
               end
             end
@@ -113,7 +148,7 @@ module Fluent
           end
 
           e.elements.each do |elem|
-            unless ['source', 'match', 'filter', 'label'].include?(elem.name)
+            unless supported_directives.include?(elem.name)
               raise Fluent::ConfigError, "<worker> section cannot have <#{elem.name}> directive"
             end
             elem.set_target_worker_id(target_worker_id)
@@ -148,6 +183,8 @@ module Fluent
 
       super
 
+      setup_source_only_buffer_agent if @source_only_mode.enabled?
+
       # initialize <source> elements
       if @without_source
         log.info :worker0, "'--without-source' is applied. Ignore <source> sections"
@@ -169,16 +206,36 @@ module Fluent
       @error_collector = error_label.event_router
     end
 
-    def lifecycle(desc: false, kind_callback: nil)
-      kind_or_label_list = if desc
-                    [:output, :filter, @labels.values.reverse, :output_with_router, :input].flatten
-                  else
-                    [:input, :output_with_router, @labels.values, :filter, :output].flatten
-                  end
-      kind_or_label_list.each do |kind|
+    def setup_source_only_buffer_agent(flush: false)
+      @source_only_buffer_agent = SourceOnlyBufferAgent.new(log: log, system_config: Fluent::Engine.system_config)
+      @source_only_buffer_agent.configure(flush: flush)
+    end
+
+    def cleanup_source_only_buffer_agent
+      @source_only_buffer_agent&.cleanup
+    end
+
+    def lifecycle(desc: false, kind_callback: nil, kind_or_agent_list: nil)
+      only_zero_downtime_restart_ready = false
+
+      unless kind_or_agent_list
+        if @source_only_mode.enabled?
+          kind_or_agent_list = [:input, @source_only_buffer_agent]
+          only_zero_downtime_restart_ready = @source_only_mode.only_zero_downtime_restart_ready?
+        elsif @source_only_buffer_agent
+          # source_only_buffer_agent can re-reroute events, so the priority is equal to output_with_router.
+          kind_or_agent_list = [:input, :output_with_router, @source_only_buffer_agent, @labels.values, :filter, :output].flatten
+        else
+          kind_or_agent_list = [:input, :output_with_router, @labels.values, :filter, :output].flatten
+        end
+
+        kind_or_agent_list.reverse! if desc
+      end
+
+      kind_or_agent_list.each do |kind|
         if kind.respond_to?(:lifecycle)
-          label = kind
-          label.lifecycle(desc: desc) do |plugin, display_kind|
+          agent = kind
+          agent.lifecycle(desc: desc) do |plugin, display_kind|
             yield plugin, display_kind
           end
         else
@@ -189,6 +246,9 @@ module Fluent
                  end
           display_kind = (kind == :output_with_router ? :output : kind)
           list.each do |instance|
+            if only_zero_downtime_restart_ready
+              next unless instance.respond_to?(:zero_downtime_restart_ready?) and instance.zero_downtime_restart_ready?
+            end
             yield instance, display_kind
           end
         end
@@ -198,8 +258,8 @@ module Fluent
       end
     end
 
-    def start
-      lifecycle(desc: true) do |i| # instance
+    def start(kind_or_agent_list: nil)
+      lifecycle(desc: true, kind_or_agent_list: kind_or_agent_list) do |i| # instance
         i.start unless i.started?
         # Input#start sometimes emits lots of events with in_tail/`read_from_head true` case
         # and it causes deadlock for small buffer/queue output. To avoid such problem,
@@ -231,13 +291,46 @@ module Fluent
       flushing_threads.each{|t| t.join }
     end
 
-    def shutdown # Fluentd's shutdown sequence is stop, before_shutdown, shutdown, after_shutdown, close, terminate for plugins
+    def cancel_source_only!
+      unless @source_only_mode.enabled?
+        log.info "do nothing for canceling with-source-only because the current mode is not with-source-only."
+        return
+      end
+
+      log.info "cancel with-source-only mode and start the other plugins"
+      all_plugins = [:input, :output_with_router, @labels.values, :filter, :output].flatten.reverse
+      start(kind_or_agent_list: all_plugins)
+
+      lifecycle_control_list[:input].each(&:event_emitter_cancel_source_only)
+
+      # Want to make sure that the source_only_router finishes all process before
+      # shutting down the agent.
+      # Strictly speaking, it would be necessary to have exclusive lock between
+      # EventRouter and the shutting down process of this agent.
+      # However, adding lock to EventRouter would worsen its performance, and
+      # the entire shutting down process does not care about it either.
+      # So, sleep here just in case.
+      sleep 1
+
+      shutdown(kind_or_agent_list: [@source_only_buffer_agent])
+      @source_only_buffer_agent = nil
+
+      # This agent can stop after flushing its all buffer, but it is not implemented for now.
+      log.info "starts the loading agent for with-source-only"
+      setup_source_only_buffer_agent(flush: true)
+      start(kind_or_agent_list: [@source_only_buffer_agent])
+
+      @source_only_mode.disable!
+    end
+
+    def shutdown(kind_or_agent_list: nil)
+      # Fluentd's shutdown sequence is stop, before_shutdown, shutdown, after_shutdown, close, terminate for plugins
       # These method callers does `rescue Exception` to call methods of shutdown sequence as far as possible
       # if plugin methods does something like infinite recursive call, `exit`, unregistering signal handlers or others.
       # Plugins should be separated and be in sandbox to protect data in each plugins/buffers.
 
       lifecycle_safe_sequence = ->(method, checker) {
-        lifecycle do |instance, kind|
+        lifecycle(kind_or_agent_list: kind_or_agent_list) do |instance, kind|
           begin
             log.debug "calling #{method} on #{kind} plugin", type: Plugin.lookup_type_from_class(instance.class), plugin_id: instance.plugin_id
             instance.__send__(method) unless instance.__send__(checker)
@@ -260,7 +353,7 @@ module Fluent
           operation_threads.each{|t| t.join }
           operation_threads.clear
         }
-        lifecycle(kind_callback: callback) do |instance, kind|
+        lifecycle(kind_callback: callback, kind_or_agent_list: kind_or_agent_list) do |instance, kind|
           t = Thread.new do
             Thread.current.abort_on_exception = true
             begin
@@ -301,6 +394,8 @@ module Fluent
       lifecycle_unsafe_sequence.call(:close, :closed?)
 
       lifecycle_safe_sequence.call(:terminate, :terminated?)
+
+      cleanup_source_only_buffer_agent unless kind_or_agent_list
     end
 
     def suppress_interval(interval_time)
@@ -318,6 +413,7 @@ module Fluent
       # See also 'fluentd/plugin/input.rb'
       input.context_router = @event_router
       input.configure(conf)
+      input.event_emitter_apply_source_only if @source_only_mode.enabled?
       if @enable_input_metrics
         @event_router.add_metric_callbacks(input.plugin_id, Proc.new {|es| input.metric_callback(es) })
       end