fluentd 0.10.36 → 0.10.37

data/lib/fluent/status.rb

@@ -16,39 +16,34 @@
 #    limitations under the License.
 #
 module Fluent
-
-
-
-class StatusClass
-  def initialize
-    @entries = {}
-    @mutex = Mutex.new
-  end
-
-  def register(instance, name, &block)
-    @mutex.synchronize {
-      (@entries[instance.object_id] ||= {})[name] = block
-    }
-    nil
-  end
-
-  def each(&block)
-    @mutex.synchronize {
-      @entries.each {|obj_id,hash|
-        record = {}
-        hash.each_pair {|name,block|
-          record[name] = block.call
+  class StatusClass
+    def initialize
+      @entries = {}
+      @mutex = Mutex.new
+    end
+
+    def register(instance, name, &block)
+      @mutex.synchronize {
+        (@entries[instance.object_id] ||= {})[name] = block
+      }
+      nil
+    end
+
+    def each(&block)
+      @mutex.synchronize {
+        @entries.each {|obj_id,hash|
+          record = {}
+          hash.each_pair {|name,block|
+            record[name] = block.call
+          }
+          block.call(record)
         }
-        block.call(record)
       }
-    }
+    end
   end
-end
-
-# Don't use this class from plugins.
-# The interface may be changed
-Status = StatusClass.new
-
 
+  # Don't use this class from plugins.
+  # The interface may be changed
+  Status = StatusClass.new
 end
 

data/lib/fluent/supervisor.rb

@@ -16,364 +16,360 @@
 #    limitations under the License.
 #
 module Fluent
+  class Supervisor
+    class LoggerInitializer
+      def initialize(path, level, chuser, chgroup)
+        @path = path
+        @level = level
+        @chuser = chuser
+        @chgroup = chgroup
+      end
 
-
-class Supervisor
-  class LoggerInitializer
-    def initialize(path, level, chuser, chgroup)
-      @path = path
-      @level = level
-      @chuser = chuser
-      @chgroup = chgroup
-    end
-
-    def init
-      if @path && @path != "-"
-        @io = File.open(@path, "a")
-        if @chuser || @chgroup
-          chuid = @chuser ? `id -u #{@chuser}`.to_i : nil
-          chgid = @chgroup ? `id -g #{@chgroup}`.to_i : nil
-          File.chown(chuid, chgid, @path)
+      def init
+        if @path && @path != "-"
+          @io = File.open(@path, "a")
+          if @chuser || @chgroup
+            chuid = @chuser ? `id -u #{@chuser}`.to_i : nil
+            chgid = @chgroup ? `id -g #{@chgroup}`.to_i : nil
+            File.chown(chuid, chgid, @path)
+          end
+        else
+          @io = STDOUT
         end
-      else
-        @io = STDOUT
-      end
 
-      $log = Fluent::Log.new(@io, @level)
+        $log = Fluent::Log.new(@io, @level)
 
-      $log.enable_color(false) if @path
-      $log.enable_debug if @level <= Fluent::Log::LEVEL_DEBUG
-    end
+        $log.enable_color(false) if @path
+        $log.enable_debug if @level <= Fluent::Log::LEVEL_DEBUG
+      end
 
-    def stdout?
-      @io == STDOUT
-    end
+      def stdout?
+        @io == STDOUT
+      end
 
-    def reopen!
-      if @path && @path != "-"
-        @io.reopen(@path, "a")
+      def reopen!
+        if @path && @path != "-"
+          @io.reopen(@path, "a")
+        end
+        self
       end
-      self
     end
-  end
 
-  def initialize(opt)
-    @config_path = opt[:config_path]
-    @log_path = opt[:log_path]
-    @log_level = opt[:log_level]
-    @daemonize = opt[:daemonize]
-    @chgroup = opt[:chgroup]
-    @chuser = opt[:chuser]
-    @libs = opt[:libs]
-    @plugin_dirs = opt[:plugin_dirs]
-    @inline_config = opt[:inline_config]
-    @suppress_interval = opt[:suppress_interval]
-    @dry_run = opt[:dry_run]
-
-    @log = LoggerInitializer.new(@log_path, @log_level, @chuser, @chgroup)
-    @finished = false
-    @main_pid = nil
-  end
+    def initialize(opt)
+      @config_path = opt[:config_path]
+      @log_path = opt[:log_path]
+      @log_level = opt[:log_level]
+      @daemonize = opt[:daemonize]
+      @chgroup = opt[:chgroup]
+      @chuser = opt[:chuser]
+      @libs = opt[:libs]
+      @plugin_dirs = opt[:plugin_dirs]
+      @inline_config = opt[:inline_config]
+      @suppress_interval = opt[:suppress_interval]
+      @dry_run = opt[:dry_run]
+
+      @log = LoggerInitializer.new(@log_path, @log_level, @chuser, @chgroup)
+      @finished = false
+      @main_pid = nil
+    end
 
-  def start
-    require 'fluent/load'
-    @log.init
-
-    dry_run if @dry_run
-    start_daemonize if @daemonize
-    install_supervisor_signal_handlers
-    until @finished
-      supervise do
-        read_config
-        change_privilege
-        init_engine
-        install_main_process_signal_handlers
-        run_configure
-        finish_daemonize if @daemonize
-        run_engine
-        exit 0
+    def start
+      require 'fluent/load'
+      @log.init
+
+      dry_run if @dry_run
+      start_daemonize if @daemonize
+      install_supervisor_signal_handlers
+      until @finished
+        supervise do
+          read_config
+          change_privilege
+          init_engine
+          install_main_process_signal_handlers
+          run_configure
+          finish_daemonize if @daemonize
+          run_engine
+          exit 0
+        end
+        $log.error "fluentd main process died unexpectedly. restarting." unless @finished
       end
-      $log.error "fluentd main process died unexpectedly. restarting." unless @finished
     end
-  end
-
-  private
-
-  def dry_run
-    read_config
-    change_privilege
-    init_engine
-    install_main_process_signal_handlers
-    run_configure
-    exit 0
-  rescue => e
-    $log.error "Dry run failed: #{e}"
-    exit 1
-  end
 
-  def start_daemonize
-    @wait_daemonize_pipe_r, @wait_daemonize_pipe_w = IO.pipe
+    private
 
-    if fork
-      # console process
-      @wait_daemonize_pipe_w.close
-      @wait_daemonize_pipe_w = nil
-      wait_daemonize
+    def dry_run
+      read_config
+      change_privilege
+      init_engine
+      install_main_process_signal_handlers
+      run_configure
       exit 0
+    rescue => e
+      $log.error "Dry run failed: #{e}"
+      exit 1
     end
 
-    # daemonize intermediate process
-    @wait_daemonize_pipe_r.close
-    @wait_daemonize_pipe_r = nil
+    def start_daemonize
+      @wait_daemonize_pipe_r, @wait_daemonize_pipe_w = IO.pipe
 
-    # in case the child process forked during run_configure
-    @wait_daemonize_pipe_w.fcntl(Fcntl::F_SETFD, Fcntl::FD_CLOEXEC)
+      if fork
+        # console process
+        @wait_daemonize_pipe_w.close
+        @wait_daemonize_pipe_w = nil
+        wait_daemonize
+        exit 0
+      end
 
-    Process.setsid
-    exit!(0) if fork
-    File.umask(0)
+      # daemonize intermediate process
+      @wait_daemonize_pipe_r.close
+      @wait_daemonize_pipe_r = nil
 
-    # supervisor process
-    @supervisor_pid = Process.pid
-  end
+      # in case the child process forked during run_configure
+      @wait_daemonize_pipe_w.fcntl(Fcntl::F_SETFD, Fcntl::FD_CLOEXEC)
 
-  def wait_daemonize
-    supervisor_pid = @wait_daemonize_pipe_r.read
-    if supervisor_pid.empty?
-      # initialization failed
-      exit! 1
+      Process.setsid
+      exit!(0) if fork
+      File.umask(0)
+
+      # supervisor process
+      @supervisor_pid = Process.pid
     end
 
-    @wait_daemonize_pipe_r.close
-    @wait_daemonize_pipe_r = nil
+    def wait_daemonize
+      supervisor_pid = @wait_daemonize_pipe_r.read
+      if supervisor_pid.empty?
+        # initialization failed
+        exit! 1
+      end
 
-    # write pid file
-    File.open(@daemonize, "w") {|f|
-      f.write supervisor_pid
-    }
-  end
+      @wait_daemonize_pipe_r.close
+      @wait_daemonize_pipe_r = nil
 
-  def finish_daemonize
-    if @wait_daemonize_pipe_w
-      STDIN.reopen("/dev/null")
-      STDOUT.reopen("/dev/null", "w")
-      STDERR.reopen("/dev/null", "w")
-      @wait_daemonize_pipe_w.write @supervisor_pid.to_s
-      @wait_daemonize_pipe_w.close
-      @wait_daemonize_pipe_w = nil
+      # write pid file
+      File.open(@daemonize, "w") {|f|
+        f.write supervisor_pid
+      }
     end
-  end
-
-  def supervise(&block)
-    start_time = Time.now
 
-    $log.info "starting fluentd-#{Fluent::VERSION}"
-    @main_pid = fork do
-      main_process(&block)
+    def finish_daemonize
+      if @wait_daemonize_pipe_w
+        STDIN.reopen("/dev/null")
+        STDOUT.reopen("/dev/null", "w")
+        STDERR.reopen("/dev/null", "w")
+        @wait_daemonize_pipe_w.write @supervisor_pid.to_s
+        @wait_daemonize_pipe_w.close
+        @wait_daemonize_pipe_w = nil
+      end
     end
 
-    if @daemonize && @wait_daemonize_pipe_w
-      STDIN.reopen("/dev/null")
-      STDOUT.reopen("/dev/null", "w")
-      STDERR.reopen("/dev/null", "w")
-      @wait_daemonize_pipe_w.close
-      @wait_daemonize_pipe_w = nil
-    end
+    def supervise(&block)
+      start_time = Time.now
 
-    Process.waitpid(@main_pid)
-    @main_pid = nil
-    ecode = $?.to_i
+      $log.info "starting fluentd-#{Fluent::VERSION}"
+      @main_pid = fork do
+        main_process(&block)
+      end
 
-    $log.info "process finished", :code=>ecode
+      if @daemonize && @wait_daemonize_pipe_w
+        STDIN.reopen("/dev/null")
+        STDOUT.reopen("/dev/null", "w")
+        STDERR.reopen("/dev/null", "w")
+        @wait_daemonize_pipe_w.close
+        @wait_daemonize_pipe_w = nil
+      end
 
-    if !@finished && Time.now - start_time < 1
-      $log.warn "process died within 1 second. exit."
-      exit ecode
-    end
-  end
+      Process.waitpid(@main_pid)
+      @main_pid = nil
+      ecode = $?.to_i
 
-  def main_process(&block)
-    begin
-      block.call
-
-    rescue Fluent::ConfigError
-      $log.error "config error", :file=>@config_path, :error=>$!.to_s
-      $log.debug_backtrace
-      unless @log.stdout?
-        console = Fluent::Log.new(STDOUT, @log_level).enable_debug
-        console.error "config error", :file=>@config_path, :error=>$!.to_s
-        console.debug_backtrace
-      end
+      $log.info "process finished", :code=>ecode
 
-    rescue
-      $log.error "unexpected error", :error=>$!.to_s
-      $log.error_backtrace
-      unless @log.stdout?
-        console = Fluent::Log.new(STDOUT, @log_level).enable_debug
-        console.error "unexpected error", :error=>$!.to_s
-        console.error_backtrace
+      if !@finished && Time.now - start_time < 1
+        $log.warn "process died within 1 second. exit."
+        exit ecode
       end
     end
 
-    exit! 1
-  end
+    def main_process(&block)
+      begin
+        block.call
+
+      rescue Fluent::ConfigError
+        $log.error "config error", :file=>@config_path, :error=>$!.to_s
+        $log.debug_backtrace
+        unless @log.stdout?
+          console = Fluent::Log.new(STDOUT, @log_level).enable_debug
+          console.error "config error", :file=>@config_path, :error=>$!.to_s
+          console.debug_backtrace
+        end
 
-  def install_supervisor_signal_handlers
-    trap :INT do
-      $log.debug "fluentd supervisor process get SIGINT"
-      @finished = true
-      if pid = @main_pid
-        # kill processes only still exists
-        unless Process.waitpid(pid, Process::WNOHANG)
-          begin
-            Process.kill(:INT, pid)
-          rescue Errno::ESRCH
-            # ignore processes already died
-          end
+      rescue
+        $log.error "unexpected error", :error=>$!.to_s
+        $log.error_backtrace
+        unless @log.stdout?
+          console = Fluent::Log.new(STDOUT, @log_level).enable_debug
+          console.error "unexpected error", :error=>$!.to_s
+          console.error_backtrace
         end
       end
+
+      exit! 1
     end
 
-    trap :TERM do
-      $log.debug "fluentd supervisor process get SIGTERM"
-      @finished = true
-      if pid = @main_pid
-        # kill processes only still exists
-        unless Process.waitpid(pid, Process::WNOHANG)
-          begin
-            Process.kill(:TERM, pid)
-          rescue Errno::ESRCH
-            # ignore processes already died
+    def install_supervisor_signal_handlers
+      trap :INT do
+        $log.debug "fluentd supervisor process get SIGINT"
+        @finished = true
+        if pid = @main_pid
+          # kill processes only still exists
+          unless Process.waitpid(pid, Process::WNOHANG)
+            begin
+              Process.kill(:INT, pid)
+            rescue Errno::ESRCH
+              # ignore processes already died
+            end
           end
         end
       end
-    end
 
-    trap :HUP do
-      $log.debug "fluentd supervisor process get SIGHUP"
-      $log.info "restarting"
-      if pid = @main_pid
-        Process.kill(:TERM, pid)
-        # don't resuce Erro::ESRSH here (invalid status)
+      trap :TERM do
+        $log.debug "fluentd supervisor process get SIGTERM"
+        @finished = true
+        if pid = @main_pid
+          # kill processes only still exists
+          unless Process.waitpid(pid, Process::WNOHANG)
+            begin
+              Process.kill(:TERM, pid)
+            rescue Errno::ESRCH
+              # ignore processes already died
+            end
+          end
+        end
       end
-    end
 
-    trap :USR1 do
-      $log.debug "fluentd supervisor process get SIGUSR1"
-      @log.reopen!
-      if pid = @main_pid
-        Process.kill(:USR1, pid)
-        # don't resuce Erro::ESRSH here (invalid status)
+      trap :HUP do
+        $log.debug "fluentd supervisor process get SIGHUP"
+        $log.info "restarting"
+        if pid = @main_pid
+          Process.kill(:TERM, pid)
+          # don't resuce Erro::ESRSH here (invalid status)
+        end
+      end
+
+      trap :USR1 do
+        $log.debug "fluentd supervisor process get SIGUSR1"
+        @log.reopen!
+        if pid = @main_pid
+          Process.kill(:USR1, pid)
+          # don't resuce Erro::ESRSH here (invalid status)
+        end
       end
     end
-  end
 
-  def read_config
-    $log.info "reading config file", :path=>@config_path
-    @config_fname = File.basename(@config_path)
-    @config_basedir = File.dirname(@config_path)
-    @config_data = File.read(@config_path)
-    if @inline_config == '-'
-      @config_data << "\n" << STDIN.read
-    elsif @inline_config
-      @config_data << "\n" << @inline_config.gsub("\\n","\n")
+    def read_config
+      $log.info "reading config file", :path=>@config_path
+      @config_fname = File.basename(@config_path)
+      @config_basedir = File.dirname(@config_path)
+      @config_data = File.read(@config_path)
+      if @inline_config == '-'
+        @config_data << "\n" << STDIN.read
+      elsif @inline_config
+        @config_data << "\n" << @inline_config.gsub("\\n","\n")
+      end
     end
-  end
 
-  def run_configure
-    Fluent::Engine.parse_config(@config_data, @config_fname, @config_basedir)
-  end
+    def run_configure
+      Fluent::Engine.parse_config(@config_data, @config_fname, @config_basedir)
+    end
 
-  def change_privilege
-    if @chgroup
-      chgid = @chgroup.to_i
-      if chgid.to_s != @chgroup
-        chgid = `id -g #{@chgroup}`.to_i
-        if $?.to_i != 0
-          exit 1
+    def change_privilege
+      if @chgroup
+        chgid = @chgroup.to_i
+        if chgid.to_s != @chgroup
+          chgid = `id -g #{@chgroup}`.to_i
+          if $?.to_i != 0
+            exit 1
+          end
         end
+        Process::GID.change_privilege(chgid)
       end
-      Process::GID.change_privilege(chgid)
-    end
 
-    if @chuser
-      chuid = @chuser.to_i
-      if chuid.to_s != @chuser
-        chuid = `id -u #{@chuser}`.to_i
+      if @chuser
+        chuid = @chuser.to_i
+        if chuid.to_s != @chuser
+          chuid = `id -u #{@chuser}`.to_i
+          if $?.to_i != 0
+            exit 1
+          end
+        end
+
+        user_groups = `id -G #{@chuser}`.split.map(&:to_i)
         if $?.to_i != 0
           exit 1
         end
+
+        Process.groups = Process.groups | user_groups
+        Process::UID.change_privilege(chuid)
       end
+    end
 
-      user_groups = `id -G #{@chuser}`.split.map(&:to_i)
-      if $?.to_i != 0
-        exit 1
+    def init_engine
+      require 'fluent/load'
+      Fluent::Engine.init
+      if @suppress_interval
+        Fluent::Engine.suppress_interval(@suppress_interval)
       end
 
-      Process.groups = Process.groups | user_groups
-      Process::UID.change_privilege(chuid)
-    end
-  end
+      @libs.each {|lib|
+        require lib
+      }
 
-  def init_engine
-    require 'fluent/load'
-    Fluent::Engine.init
-    if @suppress_interval
-      Fluent::Engine.suppress_interval(@suppress_interval)
+      @plugin_dirs.each {|dir|
+        if Dir.exist?(dir)
+          dir = File.expand_path(dir)
+          Fluent::Engine.load_plugin_dir(dir)
+        end
+      }
     end
 
-    @libs.each {|lib|
-      require lib
-    }
+    def install_main_process_signal_handlers
+      # Strictly speaking, these signal handling is not thread safe.
+      # But enough safe to limit twice call of Fluent::Engine.stop.
 
-    @plugin_dirs.each {|dir|
-      if Dir.exist?(dir)
-        dir = File.expand_path(dir)
-        Fluent::Engine.load_plugin_dir(dir)
+      trap :INT do
+        $log.debug "fluentd main process get SIGINT"
+        unless @finished
+          @finished = true
+          $log.debug "getting start to shutdown main process"
+          Fluent::Engine.stop
+        end
       end
-    }
-  end
 
-  def install_main_process_signal_handlers
-    # Strictly speaking, these signal handling is not thread safe.
-    # But enough safe to limit twice call of Fluent::Engine.stop.
-
-    trap :INT do
-      $log.debug "fluentd main process get SIGINT"
-      unless @finished
-        @finished = true
-        $log.debug "getting start to shutdown main process"
-        Fluent::Engine.stop
+      trap :TERM do
+        $log.debug "fluentd main process get SIGTERM"
+        unless @finished
+          @finished = true
+          $log.debug "getting start to shutdown main process"
+          Fluent::Engine.stop
+        end
       end
-    end
 
-    trap :TERM do
-      $log.debug "fluentd main process get SIGTERM"
-      unless @finished
-        @finished = true
-        $log.debug "getting start to shutdown main process"
-        Fluent::Engine.stop
+      trap :HUP do
+        # TODO
+        $log.debug "fluentd main process get SIGHUP"
       end
-    end
 
-    trap :HUP do
-      # TODO
-      $log.debug "fluentd main process get SIGHUP"
+      trap :USR1 do
+        $log.debug "fluentd main process get SIGUSR1"
+        $log.info "force flushing buffered events"
+        @log.reopen!
+        Fluent::Engine.flush!
+      end
     end
 
-    trap :USR1 do
-      $log.debug "fluentd main process get SIGUSR1"
-      $log.info "force flushing buffered events"
-      @log.reopen!
-      Fluent::Engine.flush!
+    def run_engine
+      Fluent::Engine.run
     end
   end
-
-  def run_engine
-    Fluent::Engine.run
-  end
-end
-
-
 end