fluentd 0.10.35 → 0.10.36

data/lib/fluent/plugin/in_debug_agent.rb

@@ -16,42 +16,38 @@
 #    limitations under the License.
 #
 module Fluent
+  class DebugAgentInput < Input
+    Plugin.register_input('debug_agent', self)
 
+    def initialize
+      require 'drb/drb'
+      super
+    end
 
-class DebugAgentInput < Input
-  Plugin.register_input('debug_agent', self)
-
-  def initialize
-    require 'drb/drb'
-    super
-  end
-
-  config_param :bind, :string, :default => '0.0.0.0'
-  config_param :port, :integer, :default => 24230
-  config_param :unix_path, :integer, :default => nil
-  #config_param :unix_mode  # TODO
-  config_param :object, :string, :default => 'Engine'
+    config_param :bind, :string, :default => '0.0.0.0'
+    config_param :port, :integer, :default => 24230
+    config_param :unix_path, :integer, :default => nil
+    #config_param :unix_mode  # TODO
+    config_param :object, :string, :default => 'Engine'
 
-  def configure(conf)
-    super
-  end
+    def configure(conf)
+      super
+    end
 
-  def start
-    if @unix_path
-      require 'drb/unix'
-      uri = "drbunix:#{@unix_path}"
-    else
-      uri = "druby://#{@bind}:#{@port}"
+    def start
+      if @unix_path
+        require 'drb/unix'
+        uri = "drbunix:#{@unix_path}"
+      else
+        uri = "druby://#{@bind}:#{@port}"
+      end
+      $log.info "listening dRuby", :uri => uri, :object => @object
+      obj = eval(@object)
+      @server = DRb::DRbServer.new(uri, obj)
     end
-    $log.info "listening dRuby", :uri => uri, :object => @object
-    obj = eval(@object)
-    @server = DRb::DRbServer.new(uri, obj)
-  end
 
-  def shutdown
-    @server.stop_service if @server
+    def shutdown
+      @server.stop_service if @server
+    end
   end
 end
-
-
-end

data/lib/fluent/plugin/in_exec.rb

@@ -16,117 +16,113 @@
 #    limitations under the License.
 #
 module Fluent
+  class ExecInput < Input
+    Plugin.register_input('exec', self)
 
+    def initialize
+      super
+    end
 
-class ExecInput < Input
-  Plugin.register_input('exec', self)
-
-  def initialize
-    super
-  end
+    config_param :command, :string
+    config_param :keys, :string
+    config_param :tag, :string, :default => nil
+    config_param :tag_key, :string, :default => nil
+    config_param :time_key, :string, :default => nil
+    config_param :time_format, :string, :default => nil
+    config_param :run_interval, :time, :default => nil
+
+    def configure(conf)
+      super
+
+      if localtime = conf['localtime']
+        @localtime = true
+      elsif utc = conf['utc']
+        @localtime = false
+      end
 
-  config_param :command, :string
-  config_param :keys, :string
-  config_param :tag, :string, :default => nil
-  config_param :tag_key, :string, :default => nil
-  config_param :time_key, :string, :default => nil
-  config_param :time_format, :string, :default => nil
-  config_param :run_interval, :time, :default => nil
+      if !@tag && !@tag_key
+        raise ConfigError, "'tag' or 'tag_key' option is required on exec input"
+      end
 
-  def configure(conf)
-    super
+      @keys = @keys.split(',')
 
-    if localtime = conf['localtime']
-      @localtime = true
-    elsif utc = conf['utc']
-      @localtime = false
+      if @time_key
+        if @time_format
+          f = @time_format
+          @time_parse_proc = Proc.new {|str| Time.strptime(str, f).to_i }
+        else
+          @time_parse_proc = Proc.new {|str| str.to_i }
+        end
+      end
     end
 
-    if !@tag && !@tag_key
-      raise ConfigError, "'tag' or 'tag_key' option is required on exec input"
+    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
 
-    @keys = @keys.split(',')
-
-    if @time_key
-      if @time_format
-        f = @time_format
-        @time_parse_proc = Proc.new {|str| Time.strptime(str, f).to_i }
+    def shutdown
+      if @run_interval
+        @finished = true
+        @thread.join
       else
-        @time_parse_proc = Proc.new {|str| str.to_i }
+        Process.kill(:TERM, @pid)
+        if @thread.join(60)  # TODO wait time
+          return
+        end
+        Process.kill(:KILL, @pid)
+        @thread.join
       end
     end
-  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))
+    def run
+      @io.each_line(&method(:each_line))
     end
-  end
 
-  def shutdown
-    if @run_interval
-      @finished = true
-      @thread.join
-    else
-      Process.kill(:TERM, @pid)
-      if @thread.join(60)  # TODO wait time
-        return
+    def run_periodic
+      until @finished
+        sleep @run_interval
+        io = IO.popen(@command, "r")
+        io.each_line(&method(:each_line))
+        Process.waitpid(io.pid)
       end
-      Process.kill(:KILL, @pid)
-      @thread.join
     end
-  end
-
-  def run
-    @io.each_line(&method(:each_line))
-  end
-
-  def run_periodic
-    until @finished
-      sleep @run_interval
-      io = IO.popen(@command, "r")
-      io.each_line(&method(:each_line))
-      Process.waitpid(io.pid)
-    end
-  end
-
-  private
-  def each_line(line)
-    begin
-      line.chomp!
-      vals = line.split("\t")
 
-      tag = @tag
-      time = nil
-      record = {}
-      for i in 0..@keys.length-1
-        key = @keys[i]
-        val = vals[i]
-        if key == @time_key
-          time = @time_parse_proc.call(val)
-        elsif key == @tag_key
-          tag = val
-        else
-          record[key] = val
+    private
+    def each_line(line)
+      begin
+        line.chomp!
+        vals = line.split("\t")
+
+        tag = @tag
+        time = nil
+        record = {}
+        for i in 0..@keys.length-1
+          key = @keys[i]
+          val = vals[i]
+          if key == @time_key
+            time = @time_parse_proc.call(val)
+          elsif key == @tag_key
+            tag = val
+          else
+            record[key] = val
+          end
         end
-      end
 
-      if tag
-        time ||= Engine.now
-        Engine.emit(tag, time, record)
+        if tag
+          time ||= Engine.now
+          Engine.emit(tag, time, record)
+        end
+      rescue
+        $log.error "exec failed to emit", :error=>$!.to_s, :line=>line
+        $log.warn_backtrace $!.backtrace
       end
-    rescue
-      $log.error "exec failed to emit", :error=>$!.to_s, :line=>line
-      $log.warn_backtrace $!.backtrace
     end
   end
 end
-
-
-end

data/lib/fluent/plugin/in_forward.rb

@@ -18,207 +18,207 @@
 module Fluent
 
 
-class ForwardInput < Input
-  Plugin.register_input('forward', self)
+  class ForwardInput < Input
+    Plugin.register_input('forward', self)
 
-  def initialize
-    super
-    require 'fluent/plugin/socket_util'
-  end
-
-  config_param :port, :integer, :default => DEFAULT_LISTEN_PORT
-  config_param :bind, :string, :default => '0.0.0.0'
-
-  def configure(conf)
-    super
-  end
+    def initialize
+      super
+      require 'fluent/plugin/socket_util'
+    end
 
-  def start
-    @loop = Coolio::Loop.new
+    config_param :port, :integer, :default => DEFAULT_LISTEN_PORT
+    config_param :bind, :string, :default => '0.0.0.0'
+    config_param :backlog, :integer, :default => nil
 
-    @lsock = listen
-    @loop.attach(@lsock)
+    def configure(conf)
+      super
+    end
 
-    @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)
+    def start
+      @loop = Coolio::Loop.new
 
-    @thread = Thread.new(&method(:run))
-    @cached_unpacker = $use_msgpack_5 ? nil : MessagePack::Unpacker.new
-  end
+      @lsock = listen
+      @loop.attach(@lsock)
 
-  def shutdown
-    @loop.watchers.each {|w| w.detach }
-    @loop.stop
-    @usock.close
-    listen_address = (@bind == '0.0.0.0' ? '127.0.0.1' : @bind)
-    TCPSocket.open(listen_address, @port) {|sock| }  # FIXME @thread.join blocks without this line
-    @thread.join
-    @lsock.close
-  end
+      @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)
 
-  def listen
-    $log.info "listening fluent socket on #{@bind}:#{@port}"
-    Coolio::TCPServer.new(@bind, @port, Handler, method(:on_message))
-  end
+      @thread = Thread.new(&method(:run))
+      @cached_unpacker = $use_msgpack_5 ? nil : MessagePack::Unpacker.new
+    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
-  rescue
-    $log.error "unexpected error", :error=>$!.to_s
-    $log.error_backtrace
-  end
+    def shutdown
+      @loop.watchers.each {|w| w.detach }
+      @loop.stop
+      @usock.close
+      listen_address = (@bind == '0.0.0.0' ? '127.0.0.1' : @bind)
+      TCPSocket.open(listen_address, @port) {|sock| }  # FIXME @thread.join blocks without this line
+      @thread.join
+      @lsock.close
+    end
 
-  protected
-  # message Entry {
-  #   1: long time
-  #   2: object record
-  # }
-  #
-  # message Forward {
-  #   1: string tag
-  #   2: list<Entry> entries
-  # }
-  #
-  # message PackedForward {
-  #   1: string tag
-  #   2: raw entries  # msgpack stream of Entry
-  # }
-  #
-  # message Message {
-  #   1: string tag
-  #   2: long? time
-  #   3: object record
-  # }
-  def on_message(msg)
-    if msg.nil?
-      # for future TCP heartbeat_request
-      return
+    def listen
+      $log.info "listening fluent socket on #{@bind}:#{@port}"
+      s = Coolio::TCPServer.new(@bind, @port, Handler, method(:on_message))
+      s.listen(@backlog) unless @backlog.nil?
+      s
     end
 
-    # TODO format error
-    tag = msg[0].to_s
-    entries = msg[1]
-
-    if entries.class == String
-      # PackedForward
-      es = MessagePackEventStream.new(entries, @cached_unpacker)
-      Engine.emit_stream(tag, es)
-
-    elsif entries.class == Array
-      # Forward
-      es = MultiEventStream.new
-      entries.each {|e|
-        time = e[0].to_i
-        time = (now ||= Engine.now) if time == 0
-        record = e[1]
-        es.add(time, record)
-      }
-      Engine.emit_stream(tag, es)
-
-    else
-      # Message
-      time = msg[1]
-      time = Engine.now if time == 0
-      record = msg[2]
-      Engine.emit(tag, time, record)
+    #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
+    rescue
+      $log.error "unexpected error", :error=>$!.to_s
+      $log.error_backtrace
     end
-  end
 
-  class Handler < Coolio::Socket
-    def initialize(io, on_message)
-      super(io)
-      if io.is_a?(TCPSocket)
-        opt = [1, @timeout.to_i].pack('I!I!')  # { int l_onoff; int l_linger; }
-        io.setsockopt(Socket::SOL_SOCKET, Socket::SO_LINGER, opt)
+    protected
+    # message Entry {
+    #   1: long time
+    #   2: object record
+    # }
+    #
+    # message Forward {
+    #   1: string tag
+    #   2: list<Entry> entries
+    # }
+    #
+    # message PackedForward {
+    #   1: string tag
+    #   2: raw entries  # msgpack stream of Entry
+    # }
+    #
+    # message Message {
+    #   1: string tag
+    #   2: long? time
+    #   3: object record
+    # }
+    def on_message(msg)
+      if msg.nil?
+        # for future TCP heartbeat_request
+        return
       end
-      $log.trace { "accepted fluent socket object_id=#{self.object_id}" }
-      @on_message = on_message
-    end
 
-    def on_connect
-    end
+      # TODO format error
+      tag = msg[0].to_s
+      entries = msg[1]
+
+      if entries.class == String
+        # PackedForward
+        es = MessagePackEventStream.new(entries, @cached_unpacker)
+        Engine.emit_stream(tag, es)
+
+      elsif entries.class == Array
+        # Forward
+        es = MultiEventStream.new
+        entries.each {|e|
+          time = e[0].to_i
+          time = (now ||= Engine.now) if time == 0
+          record = e[1]
+          es.add(time, record)
+        }
+        Engine.emit_stream(tag, es)
 
-    def on_read(data)
-      first = data[0]
-      if first == '{' || first == '['
-        m = method(:on_read_json)
-        @y = Yajl::Parser.new
-        @y.on_parse_complete = @on_message
       else
-        m = method(:on_read_msgpack)
-        @u = MessagePack::Unpacker.new
+        # Message
+        time = msg[1]
+        time = Engine.now if time == 0
+        record = msg[2]
+        Engine.emit(tag, time, record)
       end
+    end
 
-      (class<<self;self;end).module_eval do
-        define_method(:on_read, m)
+    class Handler < Coolio::Socket
+      def initialize(io, on_message)
+        super(io)
+        if io.is_a?(TCPSocket)
+          opt = [1, @timeout.to_i].pack('I!I!')  # { int l_onoff; int l_linger; }
+          io.setsockopt(Socket::SOL_SOCKET, Socket::SO_LINGER, opt)
+        end
+        $log.trace { "accepted fluent socket object_id=#{self.object_id}" }
+        @on_message = on_message
       end
-      m.call(data)
-    end
 
-    def on_read_json(data)
-      @y << data
-    rescue
-      $log.error "forward error: #{$!.to_s}"
-      $log.error_backtrace
-      close
-    end
+      def on_connect
+      end
 
-    def on_read_msgpack(data)
-      @u.feed_each(data, &@on_message)
-    rescue
-      $log.error "forward error: #{$!.to_s}"
-      $log.error_backtrace
-      close
-    end
+      def on_read(data)
+        first = data[0]
+        if first == '{' || first == '['
+          m = method(:on_read_json)
+          @y = Yajl::Parser.new
+          @y.on_parse_complete = @on_message
+        else
+          m = method(:on_read_msgpack)
+          @u = MessagePack::Unpacker.new
+        end
+
+        (class << self; self; end).module_eval do
+          define_method(:on_read, m)
+        end
+        m.call(data)
+      end
+
+      def on_read_json(data)
+        @y << data
+      rescue
+        $log.error "forward error: #{$!.to_s}"
+        $log.error_backtrace
+        close
+      end
+
+      def on_read_msgpack(data)
+        @u.feed_each(data, &@on_message)
+      rescue
+        $log.error "forward error: #{$!.to_s}"
+        $log.error_backtrace
+        close
+      end
 
-    def on_close
-      $log.trace { "closed fluent socket object_id=#{self.object_id}" }
+      def on_close
+        $log.trace { "closed fluent socket object_id=#{self.object_id}" }
+      end
     end
-  end
 
-  class HeartbeatRequestHandler < Coolio::IO
-    def initialize(io, callback)
-      super(io)
-      @io = io
-      @callback = callback
+    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?
+      end
     end
 
-    def on_readable
+    def on_heartbeat_request(host, port, msg)
+      #$log.trace "heartbeat request from #{host}:#{port}"
       begin
-        msg, addr = @io.recvfrom(1024)
+        @usock.send "\0", 0, host, port
       rescue Errno::EAGAIN, Errno::EWOULDBLOCK, Errno::EINTR
-        return
       end
-      host = addr[3]
-      port = addr[1]
-      @callback.call(host, port, msg)
-    rescue
-      # TODO log?
-    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
   end
 end
-
-
-end
-