fluentd 0.14.11-x64-mingw32 → 0.14.12-x64-mingw32

data/lib/fluent/plugin_helper/socket.rb

@@ -16,6 +16,7 @@
 
 require 'socket'
 require 'ipaddr'
+require 'openssl'
 
 require_relative 'socket_option'
 
@@ -29,6 +30,12 @@ module Fluent
 
       include Fluent::PluginHelper::SocketOption
 
+      TLS_DEFAULT_VERSION = :'TLSv1_2'
+      TLS_SUPPORTED_VERSIONS = [:'TLSv1_1', :'TLSv1_2']
+      ### follow httpclient configuration by nahi
+      # OpenSSL 0.9.8 default: "ALL:!ADH:!LOW:!EXP:!MD5:+SSLv2:@STRENGTH"
+      CIPHERS_DEFAULT = "ALL:!aNULL:!eNULL:!SSLv2" # OpenSSL >1.0.0 default
+
       attr_reader :_sockets # for tests
 
       # TODO: implement connection pool for specified host
@@ -49,7 +56,7 @@ module Fluent
       end
 
       def socket_create_tcp(host, port, resolve_name: false, **kwargs, &block)
-        sock = TCPSocket.new(host, port)
+        sock = WrappedSocket::TCP.new(host, port)
         socket_option_set(sock, resolve_name: resolve_name, **kwargs)
         if block
           begin
@@ -65,7 +72,7 @@ module Fluent
 
       def socket_create_udp(host, port, resolve_name: false, connect: false, **kwargs, &block)
         family = IPAddr.new(IPSocket.getaddress(host)).ipv4? ? ::Socket::AF_INET : ::Socket::AF_INET6
-        sock = UDPSocket.new(family)
+        sock = WrappedSocket::UDP.new(family)
         socket_option_set(sock, resolve_name: resolve_name, **kwargs)
         sock.connect(host, port) if connect
         if block
@@ -79,12 +86,145 @@ module Fluent
         end
       end
 
-      def socket_create_tls(host, port, resolve_name: false, certopts: {}, &block)
-        raise "not implemented yet"
+      def socket_create_tls(
+          host, port,
+          version: TLS_DEFAULT_VERSION, ciphers: CIPHERS_DEFAULT, insecure: false, verify_fqdn: true, fqdn: nil,
+          enable_system_cert_store: true, allow_self_signed_cert: false, cert_paths: nil, **kwargs, &block)
+
+        host_is_ipaddress = IPAddr.new(host) rescue false
+        fqdn ||= host unless host_is_ipaddress
+
+        context = OpenSSL::SSL::SSLContext.new(version)
+
+        if insecure
+          log.trace "setting TLS verify_mode NONE"
+          context.verify_mode = OpenSSL::SSL::VERIFY_NONE
+        else
+          cert_store = OpenSSL::X509::Store.new
+          if allow_self_signed_cert && OpenSSL::X509.const_defined?('V_FLAG_CHECK_SS_SIGNATURE')
+            cert_store.flags = OpenSSL::X509::V_FLAG_CHECK_SS_SIGNATURE
+          end
+          begin
+            if enable_system_cert_store
+              log.trace "loading system default certificate store"
+              cert_store.set_default_paths
+            end
+          rescue OpenSSL::X509::StoreError
+            log.warn "failed to load system default certificate store", error: e
+          end
+          if cert_paths
+            if cert_paths.respond_to?(:each)
+              cert_paths.each do |cert_path|
+                log.trace "adding CA cert", path: cert_path
+                cert_store.add_file(cert_path)
+              end
+            else
+              cert_path = cert_paths
+              log.trace "adding CA cert", path: cert_path
+              cert_store.add_file(cert_path)
+            end
+          end
+
+          log.trace "setting TLS context", mode: "peer", ciphers: ciphers
+          context.set_params({})
+          context.ciphers = ciphers
+          context.verify_mode = OpenSSL::SSL::VERIFY_PEER
+          context.cert_store = cert_store
+          context.verify_hostname = true if verify_fqdn && fqdn && context.respond_to?(:verify_hostname=)
+        end
+
+        tcpsock = socket_create_tcp(host, port, **kwargs)
+        sock = WrappedSocket::TLS.new(tcpsock, context)
+        sock.sync_close = true
+        sock.hostname = fqdn if verify_fqdn && fqdn && sock.respond_to?(:hostname=)
+
+        log.trace "entering TLS handshake"
+        sock.connect
+
+        begin
+          if verify_fqdn
+            log.trace "checking peer's certificate", subject: sock.peer_cert.subject
+            sock.post_connection_check(fqdn)
+            verify = sock.verify_result
+            if verify != OpenSSL::X509::V_OK
+              err_name = Socket.tls_verify_result_name(verify)
+              log.warn "BUG: failed to verify certification while connecting (but not raised, why?)", host: host, fqdn: fqdn, error: err_name
+              raise RuntimeError, "BUG: failed to verify certification and to handle it correctly while connecting host #{host} as #{fqdn}"
+            end
+          end
+        rescue OpenSSL::SSL::SSLError => e
+          log.warn "failed to verify certification while connecting tls session", host: host, fqdn: fqdn, error: e
+          raise
+        end
+
+        if block
+          begin
+            block.call(sock)
+          ensure
+            sock.close rescue nil
+          end
+        else
+          sock
+        end
+      end
+
+      def self.tls_verify_result_name(code)
+        case code
+        when OpenSSL::X509::V_OK then 'V_OK'
+        when OpenSSL::X509::V_ERR_AKID_SKID_MISMATCH then 'V_ERR_AKID_SKID_MISMATCH'
+        when OpenSSL::X509::V_ERR_APPLICATION_VERIFICATION then 'V_ERR_APPLICATION_VERIFICATION'
+        when OpenSSL::X509::V_ERR_CERT_CHAIN_TOO_LONG then 'V_ERR_CERT_CHAIN_TOO_LONG'
+        when OpenSSL::X509::V_ERR_CERT_HAS_EXPIRED then 'V_ERR_CERT_HAS_EXPIRED'
+        when OpenSSL::X509::V_ERR_CERT_NOT_YET_VALID then 'V_ERR_CERT_NOT_YET_VALID'
+        when OpenSSL::X509::V_ERR_CERT_REJECTED then 'V_ERR_CERT_REJECTED'
+        when OpenSSL::X509::V_ERR_CERT_REVOKED then 'V_ERR_CERT_REVOKED'
+        when OpenSSL::X509::V_ERR_CERT_SIGNATURE_FAILURE then 'V_ERR_CERT_SIGNATURE_FAILURE'
+        when OpenSSL::X509::V_ERR_CERT_UNTRUSTED then 'V_ERR_CERT_UNTRUSTED'
+        when OpenSSL::X509::V_ERR_CRL_HAS_EXPIRED then 'V_ERR_CRL_HAS_EXPIRED'
+        when OpenSSL::X509::V_ERR_CRL_NOT_YET_VALID then 'V_ERR_CRL_NOT_YET_VALID'
+        when OpenSSL::X509::V_ERR_CRL_SIGNATURE_FAILURE then 'V_ERR_CRL_SIGNATURE_FAILURE'
+        when OpenSSL::X509::V_ERR_DEPTH_ZERO_SELF_SIGNED_CERT then 'V_ERR_DEPTH_ZERO_SELF_SIGNED_CERT'
+        when OpenSSL::X509::V_ERR_ERROR_IN_CERT_NOT_AFTER_FIELD then 'V_ERR_ERROR_IN_CERT_NOT_AFTER_FIELD'
+        when OpenSSL::X509::V_ERR_ERROR_IN_CERT_NOT_BEFORE_FIELD then 'V_ERR_ERROR_IN_CERT_NOT_BEFORE_FIELD'
+        when OpenSSL::X509::V_ERR_ERROR_IN_CRL_LAST_UPDATE_FIELD then 'V_ERR_ERROR_IN_CRL_LAST_UPDATE_FIELD'
+        when OpenSSL::X509::V_ERR_ERROR_IN_CRL_NEXT_UPDATE_FIELD then 'V_ERR_ERROR_IN_CRL_NEXT_UPDATE_FIELD'
+        when OpenSSL::X509::V_ERR_INVALID_CA then 'V_ERR_INVALID_CA'
+        when OpenSSL::X509::V_ERR_INVALID_PURPOSE then 'V_ERR_INVALID_PURPOSE'
+        when OpenSSL::X509::V_ERR_KEYUSAGE_NO_CERTSIGN then 'V_ERR_KEYUSAGE_NO_CERTSIGN'
+        when OpenSSL::X509::V_ERR_OUT_OF_MEM then 'V_ERR_OUT_OF_MEM'
+        when OpenSSL::X509::V_ERR_PATH_LENGTH_EXCEEDED then 'V_ERR_PATH_LENGTH_EXCEEDED'
+        when OpenSSL::X509::V_ERR_SELF_SIGNED_CERT_IN_CHAIN then 'V_ERR_SELF_SIGNED_CERT_IN_CHAIN'
+        when OpenSSL::X509::V_ERR_SUBJECT_ISSUER_MISMATCH then 'V_ERR_SUBJECT_ISSUER_MISMATCH'
+        when OpenSSL::X509::V_ERR_UNABLE_TO_DECODE_ISSUER_PUBLIC_KEY then 'V_ERR_UNABLE_TO_DECODE_ISSUER_PUBLIC_KEY'
+        when OpenSSL::X509::V_ERR_UNABLE_TO_DECRYPT_CERT_SIGNATURE then 'V_ERR_UNABLE_TO_DECODE_ISSUER_PUBLIC_KEY'
+        when OpenSSL::X509::V_ERR_UNABLE_TO_DECRYPT_CRL_SIGNATURE then 'V_ERR_UNABLE_TO_DECRYPT_CRL_SIGNATURE'
+        when OpenSSL::X509::V_ERR_UNABLE_TO_GET_CRL then 'V_ERR_UNABLE_TO_GET_CRL'
+        when OpenSSL::X509::V_ERR_UNABLE_TO_GET_ISSUER_CERT then 'V_ERR_UNABLE_TO_GET_ISSUER_CERT'
+        when OpenSSL::X509::V_ERR_UNABLE_TO_GET_ISSUER_CERT_LOCALLY then 'V_ERR_UNABLE_TO_GET_ISSUER_CERT_LOCALLY'
+        when OpenSSL::X509::V_ERR_UNABLE_TO_VERIFY_LEAF_SIGNATURE then 'V_ERR_UNABLE_TO_VERIFY_LEAF_SIGNATURE'
+        end
       end
 
       # socket_create_socks ?
 
+      module WrappedSocket
+        class TCP < ::TCPSocket
+          def remote_addr; peeraddr[3]; end
+          def remote_host; peeraddr[2]; end
+          def remote_port; peeraddr[1]; end
+        end
+        class UDP < ::UDPSocket
+          def remote_addr; peeraddr[3]; end
+          def remote_host; peeraddr[2]; end
+          def remote_port; peeraddr[1]; end
+        end
+        class TLS < OpenSSL::SSL::SSLSocket
+          def remote_addr; peeraddr[3]; end
+          def remote_host; peeraddr[2]; end
+          def remote_port; peeraddr[1]; end
+        end
+      end
+
       def initialize
         super
         # @_sockets = [] # for keepalived sockets / connection pool

data/lib/fluent/plugin_helper/socket_option.rb

@@ -24,7 +24,7 @@ module Fluent
       FORMAT_STRUCT_LINGER  = 'I!I!' # { int l_onoff; int l_linger; }
       FORMAT_STRUCT_TIMEVAL = 'L!L!' # { time_t tv_sec; suseconds_t tv_usec; }
 
-      def socket_option_validate!(protocol, resolve_name: nil, linger_timeout: nil, recv_timeout: nil, send_timeout: nil, certopts: nil)
+      def socket_option_validate!(protocol, resolve_name: nil, linger_timeout: nil, recv_timeout: nil, send_timeout: nil)
         unless resolve_name.nil?
           if protocol != :tcp && protocol != :udp && protocol != :tls
             raise ArgumentError, "BUG: resolve_name in available for tcp/udp/tls"
@@ -35,23 +35,9 @@ module Fluent
             raise ArgumentError, "BUG: linger_timeout is available for tcp/tls"
           end
         end
-        if certopts
-          if protocol != :tls
-            raise ArgumentError, "BUG: certopts is available only for tls"
-          end
-        else
-          if protocol == :tls
-            raise ArgumentError, "BUG: certopts (certificate options) not specified for TLS"
-            socket_option_certopts_validate!(certopts)
-          end
-        end
-      end
-
-      def socket_option_certopts_validate!(certopts)
-        raise "not implemented yet"
       end
 
-      def socket_option_set(sock, resolve_name: nil, nonblock: false, linger_timeout: nil, recv_timeout: nil, send_timeout: nil, certopts: nil)
+      def socket_option_set(sock, resolve_name: nil, nonblock: false, linger_timeout: nil, recv_timeout: nil, send_timeout: nil)
         unless resolve_name.nil?
           sock.do_not_reverse_lookup = !resolve_name
         end
@@ -70,7 +56,6 @@ module Fluent
           optval = [send_timeout.to_i, 0].pack(FORMAT_STRUCT_TIMEVAL)
           socket_option_set_one(sock, :SO_SNDTIMEO, optval)
         end
-        # TODO: certopts for TLS
         sock
       end
 

data/lib/fluent/plugin_helper/storage.rb

@@ -33,6 +33,9 @@ module Fluent
         if conf && !conf.arg.empty?
           usage = conf.arg
         end
+        if !usage.empty? && usage !~ /^[a-zA-Z][-_.a-zA-Z0-9]*$/
+          raise Fluent::ConfigError, "Argument in <storage ARG> uses invalid characters: '#{usage}'"
+        end
 
         s = @_storages[usage]
         if s && s.running
@@ -59,7 +62,7 @@ module Fluent
                      conf = Hash[conf.map{|k,v| [k.to_s, v]}]
                      Fluent::Config::Element.new('storage', usage, conf, [])
                    when nil
-                     Fluent::Config::Element.new('storage', usage, {}, [])
+                     Fluent::Config::Element.new('storage', usage, {'@type' => type}, [])
                    else
                      raise ArgumentError, "BUG: conf must be a Element, Hash (or unspecified), but '#{conf.class}'"
                    end
@@ -98,6 +101,9 @@ module Fluent
         super
 
         @storage_configs.each do |section|
+          if !section.usage.empty? && section.usage !~ /^[a-zA-Z][-_.a-zA-Z0-9]*$/
+            raise Fluent::ConfigError, "Argument in <storage ARG> uses invalid characters: '#{section.usage}'"
+          end
           if @_storages[section.usage]
             raise Fluent::ConfigError, "duplicated storages configured: #{section.usage}"
           end

data/lib/fluent/plugin_helper/thread.rb

@@ -14,10 +14,13 @@
 #    limitations under the License.
 #
 
+require 'fluent/clock'
+
 module Fluent
   module PluginHelper
     module Thread
       THREAD_DEFAULT_WAIT_SECONDS = 1
+      THREAD_SHUTDOWN_HARD_TIMEOUT_IN_TESTS = 100 # second
 
       # stop     : mark callback thread as stopped
       # shutdown : [-]
@@ -38,9 +41,18 @@ module Fluent
       end
 
       def thread_wait_until_stop
-        until @_threads_mutex.synchronize{ @_threads.values.reduce(true){|r,t| r && ![:_fluentd_plugin_helper_thread_running] } }
+        timeout_at = Fluent::Clock.now + THREAD_SHUTDOWN_HARD_TIMEOUT_IN_TESTS
+        until @_threads_mutex.synchronize{ @_threads.values.reduce(true){|r,t| r && !t[:_fluentd_plugin_helper_thread_running] } }
+          break if Fluent::Clock.now > timeout_at
           sleep 0.1
         end
+        @_threads_mutex.synchronize{ @_threads.values }.each do |t|
+          if t.alive?
+            puts "going to kill the thread still running: #{t[:_fluentd_plugin_helper_thread_title]}"
+            t.kill rescue nil
+            t[:_fluentd_plugin_helper_thread_running] = false
+          end
+        end
       end
 
       # Ruby 2.2.3 or earlier (and all 2.1.x) cause bug about Threading ("Stack consistency error")
@@ -70,13 +82,13 @@ module Fluent
             thread_exit = true
             raise
           ensure
-            if ::Thread.current.alive? && !thread_exit
-              log.warn "thread doesn't exit correctly (killed or other reason)", plugin: self.class, title: title, thread: ::Thread.current, error: $!
-            end
             @_threads_mutex.synchronize do
               @_threads.delete(::Thread.current.object_id)
             end
             ::Thread.current[:_fluentd_plugin_helper_thread_running] = false
+            if ::Thread.current.alive? && !thread_exit
+              log.warn "thread doesn't exit correctly (killed or other reason)", plugin: self.class, title: title, thread: ::Thread.current, error: $!
+            end
           end
         end
         thread.abort_on_exception = true

data/lib/fluent/registry.rb

@@ -19,13 +19,14 @@ require 'fluent/config/error'
 module Fluent
   class Registry
     DEFAULT_PLUGIN_PATH = File.expand_path('../plugin', __FILE__)
+    FLUENT_LIB_PATH = File.dirname(File.dirname(DEFAULT_PLUGIN_PATH))
 
     def initialize(kind, search_prefix, dir_search_prefix: nil)
       @kind = kind
       @search_prefix = search_prefix
       @dir_search_prefix = dir_search_prefix
       @map = {}
-      @paths = [DEFAULT_PLUGIN_PATH]
+      @paths = []
     end
 
     attr_reader :kind, :paths, :map, :dir_search_prefix
@@ -73,8 +74,12 @@ module Fluent
 
       # prefer LOAD_PATH than gems
       files = $LOAD_PATH.map { |lp|
-        lpath = File.expand_path(File.join(lp, "#{path}.rb"))
-        File.exist?(lpath) ? lpath : nil
+        if lp == FLUENT_LIB_PATH
+          nil
+        else
+          lpath = File.expand_path(File.join(lp, "#{path}.rb"))
+          File.exist?(lpath) ? lpath : nil
+        end
       }.compact
       unless files.empty?
         # prefer newer version
@@ -82,18 +87,30 @@ module Fluent
         return
       end
 
+      # Find from gems and prefer newer version
       specs = Gem::Specification.find_all { |spec|
-        spec.contains_requirable_file? path
-      }
-
-      # prefer newer version
-      specs = specs.sort_by { |spec| spec.version }
+        if spec.name == 'fluentd'.freeze
+          false
+        else
+          spec.contains_requirable_file? path
+        end
+      }.sort_by { |spec| spec.version }
       if spec = specs.last
         spec.require_paths.each { |lib|
           file = "#{spec.full_gem_path}/#{lib}/#{path}"
-          require file
+          if File.exist?("#{file}.rb")
+            require file
+            return
+          end
         }
       end
+
+      # Lastly, load built-in plugin
+      lpath = File.expand_path(File.join(FLUENT_LIB_PATH, "#{@search_prefix}#{type}.rb"))
+      if File.exist?(lpath)
+        require lpath
+        return
+      end
     end
   end
 end

data/lib/fluent/root_agent.rb

@@ -87,7 +87,7 @@ module Fluent
 
       # initialize <source> elements
       if @without_source
-        log.info "'--without-source' is applied. Ignore <source> sections"
+        log.info :worker0, "'--without-source' is applied. Ignore <source> sections"
       else
         conf.elements(name: 'source').each { |e|
           type = e['@type']
@@ -196,7 +196,11 @@ module Fluent
           t = Thread.new do
             Thread.current.abort_on_exception = true
             begin
-              log.info "#{operation} #{kind} plugin", type: Plugin.lookup_type_from_class(instance.class), plugin_id: instance.plugin_id
+              if method == :shutdown
+                log.info "#{operation} #{kind} plugin", type: Plugin.lookup_type_from_class(instance.class), plugin_id: instance.plugin_id
+              else
+                log.debug "#{operation} #{kind} plugin", type: Plugin.lookup_type_from_class(instance.class), plugin_id: instance.plugin_id
+              end
               instance.send(method) unless instance.send(checker)
             rescue Exception => e
               log.warn "unexpected error while #{operation} on #{kind} plugin", plugin: instance.class, plugin_id: instance.plugin_id, error: e
@@ -227,7 +231,7 @@ module Fluent
     end
 
     def add_source(type, conf)
-      log.info "adding source", type: type
+      log.info :worker0, "adding source", type: type
 
       input = Plugin.new_input(type)
       # <source> emits events to the top-level event router (RootAgent#event_router).

data/lib/fluent/supervisor.rb

@@ -14,8 +14,6 @@
 #    limitations under the License.
 #
 
-require 'etc'
-require 'fcntl'
 require 'fileutils'
 
 require 'fluent/config'
@@ -27,7 +25,6 @@ require 'fluent/plugin'
 require 'fluent/rpc'
 require 'fluent/system_config'
 require 'serverengine'
-require 'shellwords'
 
 if Fluent.windows?
   require 'windows/library'
@@ -230,9 +227,13 @@ module Fluent
       fluentd_conf = Fluent::Config.parse(config_data, config_fname, config_basedir, params['use_v1_config'])
       system_config = SystemConfig.create(fluentd_conf)
 
-      root_dir = system_config.root_dir || params['root_dir']
-      log_level = system_config.log_level || params['log_level']
-      suppress_repeated_stacktrace = system_config.suppress_repeated_stacktrace || params['suppress_repeated_stacktrace']
+      # these params must NOT be configured via system config here.
+      # these may be overridden by command line params.
+      workers = params['workers']
+      root_dir = params['root_dir']
+      log_level = params['log_level']
+      suppress_repeated_stacktrace = params['suppress_repeated_stacktrace']
+
       log_path = params['log_path']
       chuser = params['chuser']
       chgroup = params['chgroup']
@@ -248,7 +249,7 @@ module Fluent
         log_rotate_size: log_rotate_size
       )
       # this #init sets initialized logger to $log
-      logger_initializer.init
+      logger_initializer.init(:supervisor, 0)
       logger = $log
 
       command_sender = Fluent.windows? ? "pipe" : "signal"
@@ -261,7 +262,7 @@ module Fluent
 
       se_config = {
           worker_type: 'spawn',
-          workers: 1,
+          workers: workers,
           log_stdin: false,
           log_stdout: false,
           log_stderr: false,
@@ -318,7 +319,10 @@ module Fluent
         @log_rotate_size = log_rotate_size
       end
 
-      def init
+      def init(process_type, worker_id)
+        @opts[:process_type] = process_type
+        @opts[:worker_id] = worker_id
+
         if @path && @path != "-"
           @logdev = if @log_rotate_age || @log_rotate_size
                      Fluent::LogDeviceIO.new(@path, shift_age: @log_rotate_age, shift_size: @log_rotate_size)
@@ -374,7 +378,7 @@ module Fluent
         root_dir: nil,
         suppress_interval: 0,
         suppress_repeated_stacktrace: true,
-        without_source: false,
+        without_source: nil,
         use_v1_config: true,
         supervise: true,
         standalone_worker: false,
@@ -400,12 +404,14 @@ module Fluent
       @rpc_server = nil
       @process_name = nil
 
+      @workers = opt[:workers]
       @root_dir = opt[:root_dir]
       @log_level = opt[:log_level]
       @log_rotate_age = opt[:log_rotate_age]
       @log_rotate_size = opt[:log_rotate_size]
       @suppress_interval = opt[:suppress_interval]
       @suppress_config_dump = opt[:suppress_config_dump]
+      @log_event_verbose = opt[:log_event_verbose]
       @without_source = opt[:without_source]
       @signame = opt[:signame]
 
@@ -420,11 +426,15 @@ module Fluent
     end
 
     def run_supervisor
-      @log.init
+      @log.init(:supervisor, 0)
       show_plugin_config if @show_plugin_config
       read_config
       set_system_config
 
+      if @workers < 1
+        raise Fluent::ConfigError, "invalid number of workers (must be > 0):#{@workers}"
+      end
+
       if @root_dir
         if File.exist?(@root_dir)
           unless Dir.exist?(@root_dir)
@@ -459,7 +469,13 @@ module Fluent
       rescue Exception
         # ignore LoadError and others (related with signals): it may raise these errors in Windows
       end
-      @log.init
+      worker_id = ENV['SERVERENGINE_WORKER_ID'].to_i
+      process_type = case
+                     when @standalone_worker then :standalone
+                     when worker_id == 0 then :worker0
+                     else :workers
+                     end
+      @log.init(process_type, worker_id)
       Process.setproctitle("worker:#{@process_name}") if @process_name
 
       show_plugin_config if @show_plugin_config
@@ -468,7 +484,8 @@ module Fluent
 
       install_main_process_signal_handlers
 
-      $log.info "starting fluentd-#{Fluent::VERSION} without supervision", pid: Process.pid
+      # This is the only log messsage for @standalone_worker
+      $log.info "starting fluentd-#{Fluent::VERSION} without supervision", pid: Process.pid if @standalone_worker
 
       main_process do
         create_socket_manager if @standalone_worker
@@ -542,12 +559,16 @@ module Fluent
       params['daemonize'] = @daemonize
       params['inline_config'] = @inline_config
       params['log_path'] = @log_path
-      params['log_level'] = @log_level
       params['log_rotate_age'] = @log_rotate_age
       params['log_rotate_size'] = @log_rotate_size
       params['chuser'] = @chuser
       params['chgroup'] = @chgroup
       params['use_v1_config'] = @use_v1_config
+
+      # system config parameters
+      params['workers'] = @workers
+      params['root_dir'] = @root_dir
+      params['log_level'] = @log_level
       params['suppress_repeated_stacktrace'] = @suppress_repeated_stacktrace
       params['signame'] = @signame
 
@@ -681,7 +702,7 @@ module Fluent
     end
 
     def read_config
-      $log.info "reading config file", path: @config_path
+      $log.info :supervisor, "reading config file", path: @config_path
       @config_fname = File.basename(@config_path)
       @config_basedir = File.dirname(@config_path)
       @config_data = File.read(@config_path)
@@ -695,6 +716,7 @@ module Fluent
 
     def set_system_config
       @system_config = SystemConfig.create(@conf) # @conf is set in read_config
+      @system_config.attach(self)
       @system_config.apply(self)
     end