fluentd 0.10.35 → 0.10.36

data/lib/fluent/plugin/in_object_space.rb

@@ -16,103 +16,99 @@
 #    limitations under the License.
 #
 module Fluent
+  class ObjectSpaceInput < Input
+    Plugin.register_input('object_space', self)
 
+    def initialize
+      super
+    end
 
-class ObjectSpaceInput < Input
-  Plugin.register_input('object_space', self)
-
-  def initialize
-    super
-  end
+    config_param :emit_interval, :time, :default => 60
+    config_param :tag, :string
+    config_param :top, :integer, :default => 15
 
-  config_param :emit_interval, :time, :default => 60
-  config_param :tag, :string
-  config_param :top, :integer, :default => 15
+    class TimerWatcher < Coolio::TimerWatcher
+      def initialize(interval, repeat, &callback)
+        @callback = callback
+        super(interval, repeat)
+      end
 
-  class TimerWatcher < Coolio::TimerWatcher
-    def initialize(interval, repeat, &callback)
-      @callback = callback
-      super(interval, repeat)
+      def on_timer
+        @callback.call
+      rescue
+        # TODO log?
+        $log.error $!.to_s
+        $log.error_backtrace
+      end
     end
 
-    def on_timer
-      @callback.call
-    rescue
-      # TODO log?
-      $log.error $!.to_s
-      $log.error_backtrace
+    def configure(conf)
+      super
     end
-  end
-
-  def configure(conf)
-    super
-  end
-
-  def start
-    @loop = Coolio::Loop.new
-    @timer = TimerWatcher.new(@emit_interval, true, &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
-
-  class Counter
-    def initialize(klass, init_count)
-      @klass = klass
-      @count = init_count
+    def start
+      @loop = Coolio::Loop.new
+      @timer = TimerWatcher.new(@emit_interval, true, &method(:on_timer))
+      @loop.attach(@timer)
+      @thread = Thread.new(&method(:run))
     end
 
-    def incr!
-      @count += 1
+    def shutdown
+      @loop.watchers.each {|w| w.detach }
+      @loop.stop
+      @thread.join
     end
 
-    def name
-      @klass.name
+    def run
+      @loop.run
+    rescue
+      $log.error "unexpected error", :error=>$!.to_s
+      $log.error_backtrace
     end
 
-    attr_reader :count
-  end
-
-  def on_timer
-    now = Engine.now
-
-    array = []
-    map = {}
+    class Counter
+      def initialize(klass, init_count)
+        @klass = klass
+        @count = init_count
+      end
 
-    ObjectSpace.each_object {|obj|
-      klass = obj.class rescue Object
-      if c = map[klass]
-        c.incr!
-      else
-        c = Counter.new(klass, 1)
-        array << c
-        map[klass] = c
+      def incr!
+        @count += 1
       end
-    }
 
-    array.sort_by! {|c| -c.count }
+      def name
+        @klass.name
+      end
 
-    record = {}
-    array.each_with_index {|c,i|
-      break if i >= @top
-      record[c.name] = c.count
-    }
+      attr_reader :count
+    end
 
-    Engine.emit(@tag, now, record)
+    def on_timer
+      now = Engine.now
+
+      array = []
+      map = {}
+
+      ObjectSpace.each_object {|obj|
+        klass = obj.class rescue Object
+        if c = map[klass]
+          c.incr!
+        else
+          c = Counter.new(klass, 1)
+          array << c
+          map[klass] = c
+        end
+      }
+
+      array.sort_by! {|c| -c.count }
+
+      record = {}
+      array.each_with_index {|c,i|
+        break if i >= @top
+        record[c.name] = c.count
+      }
+
+      Engine.emit(@tag, now, record)
+    end
   end
 end
-
-
-end

data/lib/fluent/plugin/in_status.rb

@@ -1,4 +1,3 @@
-
 #
 # Fluent
 #
@@ -17,65 +16,60 @@
 #    limitations under the License.
 #
 module Fluent
+  class StatusInput < Input
+    Plugin.register_input('status', self)
 
+    def initialize
+      super
+    end
 
-class StatusInput < Input
-  Plugin.register_input('status', self)
-
-  def initialize
-    super
-  end
+    config_param :emit_interval, :time, :default => 60
+    config_param :tag, :string
 
-  config_param :emit_interval, :time, :default => 60
-  config_param :tag, :string
+    class TimerWatcher < Coolio::TimerWatcher
+      def initialize(interval, repeat, &callback)
+        @callback = callback
+        super(interval, repeat)
+      end
 
-  class TimerWatcher < Coolio::TimerWatcher
-    def initialize(interval, repeat, &callback)
-      @callback = callback
-      super(interval, repeat)
+      def on_timer
+        @callback.call
+      rescue
+        # TODO log?
+        $log.error $!.to_s
+        $log.error_backtrace
+      end
     end
 
-    def on_timer
-      @callback.call
-    rescue
-      # TODO log?
-      $log.error $!.to_s
-      $log.error_backtrace
+    def configure(conf)
+      super
     end
-  end
-
-  def configure(conf)
-    super
-  end
 
-  def start
-    @loop = Coolio::Loop.new
-    @timer = TimerWatcher.new(@emit_interval, true, &method(:on_timer))
-    @loop.attach(@timer)
-    @thread = Thread.new(&method(:run))
-  end
+    def start
+      @loop = Coolio::Loop.new
+      @timer = TimerWatcher.new(@emit_interval, true, &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 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 run
+      @loop.run
+    rescue
+      $log.error "unexpected error", :error=>$!.to_s
+      $log.error_backtrace
+    end
 
-  def on_timer
-    now = Engine.now
-    Status.each {|record|
-      Engine.emit(@tag, now, record)
-    }
+    def on_timer
+      now = Engine.now
+      Status.each {|record|
+        Engine.emit(@tag, now, record)
+      }
+    end
   end
 end
-
-
-end
-

data/lib/fluent/plugin/in_stream.rb

@@ -16,193 +16,192 @@
 #    limitations under the License.
 #
 module Fluent
+  # obsolete
+  class StreamInput < Input
+    def initialize
+      require 'socket'
+      require 'yajl'
+      super
+    end
 
+    def start
+      @loop = Coolio::Loop.new
+      @lsock = listen
+      @loop.attach(@lsock)
+      @thread = Thread.new(&method(:run))
+      @cached_unpacker = $use_msgpack_5 ? nil : MessagePack::Unpacker.new
+    end
 
-# obsolete
-class StreamInput < Input
-  def initialize
-    require 'socket'
-    require 'yajl'
-    super
-  end
-
-  def start
-    @loop = Coolio::Loop.new
-    @lsock = listen
-    @loop.attach(@lsock)
-    @thread = Thread.new(&method(:run))
-    @cached_unpacker = $use_msgpack_5 ? nil : MessagePack::Unpacker.new
-  end
-
-  def shutdown
-    @loop.watchers.each {|w| w.detach }
-    @loop.stop
-    @lsock.close
-    @thread.join
-  end
-
-  #def listen
-  #end
+    def shutdown
+      @loop.watchers.each {|w| w.detach }
+      @loop.stop
+      @lsock.close
+      @thread.join
+    end
 
-  def run
-    @loop.run
-  rescue
-    $log.error "unexpected error", :error=>$!.to_s
-    $log.error_backtrace
-  end
+    #def listen
+    #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)
-    # 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)
+    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)
+      # 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)
       end
-      $log.trace { "accepted fluent socket object_id=#{self.object_id}" }
-      @on_message = on_message
     end
 
-    def on_connect
-    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)
+        end
+        $log.trace { "accepted fluent socket object_id=#{self.object_id}" }
+        @on_message = on_message
+      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
+      def on_connect
       end
 
-      (class<<self;self;end).module_eval do
-        define_method(:on_read, m)
+      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
-      m.call(data)
-    end
 
-    def on_read_json(data)
-      @y << data
-    rescue
-      $log.error "unexpected error", :error=>$!.to_s
-      $log.error_backtrace
-      close
-    end
+      def on_read_json(data)
+        @y << data
+      rescue
+        $log.error "unexpected error", :error=>$!.to_s
+        $log.error_backtrace
+        close
+      end
 
-    def on_read_msgpack(data)
-      @u.feed_each(data, &@on_message)
-    rescue
-      $log.error "unexpected error", :error=>$!.to_s
-      $log.error_backtrace
-      close
-    end
+      def on_read_msgpack(data)
+        @u.feed_each(data, &@on_message)
+      rescue
+        $log.error "unexpected error", :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
-end
 
 
-# obsolete
-# ForwardInput is backward compatible with TcpInput
-#class TcpInput < StreamInput
-#  Plugin.register_input('tcp', self)
-#
-#  config_param :port, :integer, :default => DEFAULT_LISTEN_PORT
-#  config_param :bind, :string, :default => '0.0.0.0'
-#
-#  def configure(conf)
-#    super
-#  end
-#
-#  def listen
-#    $log.debug "listening fluent socket on #{@bind}:#{@port}"
-#    Coolio::TCPServer.new(@bind, @port, Handler, method(:on_message))
-#  end
-#end
-class TcpInput < ForwardInput
-  Plugin.register_input('tcp', self)
-
-  def initialize
-    super
-    $log.warn "'tcp' input is obsoleted and will be removed soon. Use 'forward' instead."
+  # obsolete
+  # ForwardInput is backward compatible with TcpInput
+  #class TcpInput < StreamInput
+  #  Plugin.register_input('tcp', self)
+  #
+  #  config_param :port, :integer, :default => DEFAULT_LISTEN_PORT
+  #  config_param :bind, :string, :default => '0.0.0.0'
+  #
+  #  def configure(conf)
+  #    super
+  #  end
+  #
+  #  def listen
+  #    $log.debug "listening fluent socket on #{@bind}:#{@port}"
+  #    Coolio::TCPServer.new(@bind, @port, Handler, method(:on_message))
+  #  end
+  #end
+  class TcpInput < ForwardInput
+    Plugin.register_input('tcp', self)
+
+    def initialize
+      super
+      $log.warn "'tcp' input is obsoleted and will be removed soon. Use 'forward' instead."
+    end
   end
-end
 
 
-class UnixInput < StreamInput
-  Plugin.register_input('unix', self)
+  class UnixInput < StreamInput
+    Plugin.register_input('unix', self)
 
-  config_param :path, :string, :default => DEFAULT_SOCKET_PATH
+    config_param :path, :string, :default => DEFAULT_SOCKET_PATH
+    config_param :backlog, :integer, :default => nil
 
-  def configure(conf)
-    super
-    #$log.warn "'unix' input is obsoleted and will be removed. Use 'forward' instead."
-  end
+    def configure(conf)
+      super
+      #$log.warn "'unix' input is obsoleted and will be removed. Use 'forward' instead."
+    end
 
-  def listen
-    if File.exist?(@path)
-      File.unlink(@path)
+    def listen
+      if File.exist?(@path)
+        File.unlink(@path)
+      end
+      FileUtils.mkdir_p File.dirname(@path)
+      $log.debug "listening fluent socket on #{@path}"
+      s = Coolio::UNIXServer.new(@path, Handler, method(:on_message))
+      s.listen(@backlog) unless @backlog.nil?
+      s
     end
-    FileUtils.mkdir_p File.dirname(@path)
-    $log.debug "listening fluent socket on #{@path}"
-    Coolio::UNIXServer.new(@path, Handler, method(:on_message))
   end
 end
 
-
-end
-