fluentd 0.10.35 → 0.10.36

data/lib/fluent/plugin/out_copy.rb

@@ -16,58 +16,53 @@
 #    limitations under the License.
 #
 module Fluent
+  class CopyOutput < MultiOutput
+    Plugin.register_output('copy', self)
 
+    def initialize
+      @outputs = []
+    end
 
-class CopyOutput < MultiOutput
-  Plugin.register_output('copy', self)
-
-  def initialize
-    @outputs = []
-  end
-
-  attr_reader :outputs
-
-  def configure(conf)
-    conf.elements.select {|e|
-      e.name == 'store'
-    }.each {|e|
-      type = e['type']
-      unless type
-        raise ConfigError, "Missing 'type' parameter on <store> directive"
-      end
-      $log.debug "adding store type=#{type.dump}"
-
-      output = Plugin.new_output(type)
-      output.configure(e)
-      @outputs << output
-    }
-  end
+    attr_reader :outputs
 
-  def start
-    @outputs.each {|o|
-      o.start
-    }
-  end
+    def configure(conf)
+      conf.elements.select {|e|
+        e.name == 'store'
+      }.each {|e|
+        type = e['type']
+        unless type
+          raise ConfigError, "Missing 'type' parameter on <store> directive"
+        end
+        $log.debug "adding store type=#{type.dump}"
 
-  def shutdown
-    @outputs.each {|o|
-      o.shutdown
-    }
-  end
+        output = Plugin.new_output(type)
+        output.configure(e)
+        @outputs << output
+      }
+    end
 
-  def emit(tag, es, chain)
-    unless es.repeatable?
-      m = MultiEventStream.new
-      es.each {|time,record|
-        m.add(time, record)
+    def start
+      @outputs.each {|o|
+        o.start
       }
-      es = m
     end
-    chain = OutputChain.new(@outputs, tag, es, chain)
-    chain.next
-  end
-end
 
+    def shutdown
+      @outputs.each {|o|
+        o.shutdown
+      }
+    end
 
+    def emit(tag, es, chain)
+      unless es.repeatable?
+        m = MultiEventStream.new
+        es.each {|time,record|
+          m.add(time, record)
+        }
+        es = m
+      end
+      chain = OutputChain.new(@outputs, tag, es, chain)
+      chain.next
+    end
+  end
 end
-

data/lib/fluent/plugin/out_exec.rb

@@ -16,76 +16,71 @@
 #    limitations under the License.
 #
 module Fluent
+  class ExecOutput < TimeSlicedOutput
+    Plugin.register_output('exec', self)
 
+    def initialize
+      super
+      require 'tempfile'
+      @localtime = false
+    end
 
-class ExecOutput < TimeSlicedOutput
-  Plugin.register_output('exec', self)
-
-  def initialize
-    super
-    require 'tempfile'
-    @localtime = false
-  end
-
-  config_param :command, :string
-  config_param :keys, :string
-  config_param :tag_key, :string, :default => nil
-  config_param :time_key, :string, :default => nil
-  config_param :time_format, :string, :default => nil
+    config_param :command, :string
+    config_param :keys, :string
+    config_param :tag_key, :string, :default => nil
+    config_param :time_key, :string, :default => nil
+    config_param :time_format, :string, :default => nil
 
-  def configure(conf)
-    super
+    def configure(conf)
+      super
 
-    @keys = @keys.split(',')
+      @keys = @keys.split(',')
 
-    if @time_key
-      if @time_format
-        tf = TimeFormatter.new(@time_format, @localtime)
-        @time_format_proc = tf.method(:format)
-      else
-        @time_format_proc = Proc.new {|time| time.to_s }
+      if @time_key
+        if @time_format
+          tf = TimeFormatter.new(@time_format, @localtime)
+          @time_format_proc = tf.method(:format)
+        else
+          @time_format_proc = Proc.new {|time| time.to_s }
+        end
       end
     end
-  end
 
-  def format(tag, time, record)
-    out = ''
-    last = @keys.length-1
-    for i in 0..last
-      key = @keys[i]
-      if key == @time_key
-        out << @time_format_proc.call(time)
-      elsif key == @tag_key
-        out << tag
-      else
-        out << record[key].to_s
+    def format(tag, time, record)
+      out = ''
+      last = @keys.length-1
+      for i in 0..last
+        key = @keys[i]
+        if key == @time_key
+          out << @time_format_proc.call(time)
+        elsif key == @tag_key
+          out << tag
+        else
+          out << record[key].to_s
+        end
+        out << "\t" if i != last
       end
-      out << "\t" if i != last
+      out << "\n"
+      out
     end
-    out << "\n"
-    out
-  end
 
-  def write(chunk)
-    if chunk.respond_to?(:path)
-      prog = "#{@command} #{chunk.path}"
-    else
-      tmpfile = Tempfile.new("fluent-plugin-exec-")
-      chunk.write_to(tmpfile)
-      tmpfile.close
-      prog = "#{@command} #{tmpfile.path}"
-    end
+    def write(chunk)
+      if chunk.respond_to?(:path)
+        prog = "#{@command} #{chunk.path}"
+      else
+        tmpfile = Tempfile.new("fluent-plugin-exec-")
+        chunk.write_to(tmpfile)
+        tmpfile.close
+        prog = "#{@command} #{tmpfile.path}"
+      end
 
-    system(prog)
-    ecode = $?.to_i
-    tmpfile.delete if tmpfile
+      system(prog)
+      ecode = $?.to_i
+      tmpfile.delete if tmpfile
 
-    if ecode != 0
-      raise "command returns #{ecode}: #{prog}"
+      if ecode != 0
+        raise "command returns #{ecode}: #{prog}"
+      end
     end
   end
 end
-
-
-end
-

data/lib/fluent/plugin/out_exec_filter.rb

@@ -16,427 +16,423 @@
 #    limitations under the License.
 #
 module Fluent
+  class ExecFilterOutput < BufferedOutput
+    Plugin.register_output('exec_filter', self)
 
+    def initialize
+      super
+    end
 
-class ExecFilterOutput < BufferedOutput
-  Plugin.register_output('exec_filter', self)
-
-  def initialize
-    super
-  end
+    SUPPORTED_FORMAT = {
+      'tsv' => :tsv,
+      'json' => :json,
+      'msgpack' => :msgpack,
+    }
 
-  SUPPORTED_FORMAT = {
-    'tsv' => :tsv,
-    'json' => :json,
-    'msgpack' => :msgpack,
-  }
+    config_param :command, :string
 
-  config_param :command, :string
+    config_param :remove_prefix, :string, :default => nil
+    config_param :add_prefix, :string, :default => nil
 
-  config_param :remove_prefix, :string, :default => nil
-  config_param :add_prefix, :string, :default => nil
+    config_param :in_format, :default => :tsv do |val|
+      f = SUPPORTED_FORMAT[val]
+      raise ConfigError, "Unsupported in_format '#{val}'" unless f
+      f
+    end
+    config_param :in_keys, :default => [] do |val|
+      val.split(',')
+    end
+    config_param :in_tag_key, :default => nil
+    config_param :in_time_key, :default => nil
+    config_param :in_time_format, :default => nil
 
-  config_param :in_format, :default => :tsv do |val|
-    f = SUPPORTED_FORMAT[val]
-    raise ConfigError, "Unsupported in_format '#{val}'" unless f
-    f
-  end
-  config_param :in_keys, :default => [] do |val|
-    val.split(',')
-  end
-  config_param :in_tag_key, :default => nil
-  config_param :in_time_key, :default => nil
-  config_param :in_time_format, :default => nil
-
-  config_param :out_format, :default => :tsv do |val|
-    f = SUPPORTED_FORMAT[val]
-    raise ConfigError, "Unsupported out_format '#{val}'" unless f
-    f
-  end
-  config_param :out_keys, :default => [] do |val|  # for tsv format
-    val.split(',')
-  end
-  config_param :out_tag_key, :default => nil
-  config_param :out_time_key, :default => nil
-  config_param :out_time_format, :default => nil
+    config_param :out_format, :default => :tsv do |val|
+      f = SUPPORTED_FORMAT[val]
+      raise ConfigError, "Unsupported out_format '#{val}'" unless f
+      f
+    end
+    config_param :out_keys, :default => [] do |val|  # for tsv format
+      val.split(',')
+    end
+    config_param :out_tag_key, :default => nil
+    config_param :out_time_key, :default => nil
+    config_param :out_time_format, :default => nil
 
-  config_param :tag, :string, :default => nil
+    config_param :tag, :string, :default => nil
 
-  config_param :time_key, :string, :default => nil
-  config_param :time_format, :string, :default => nil
+    config_param :time_key, :string, :default => nil
+    config_param :time_format, :string, :default => nil
 
-  config_param :localtime, :bool, :default => true
-  config_param :num_children, :integer, :default => 1
+    config_param :localtime, :bool, :default => true
+    config_param :num_children, :integer, :default => 1
 
-  # nil, 'none' or 0: no respawn, 'inf' or -1: infinite times, positive integer: try to respawn specified times only
-  config_param :child_respawn, :string, :default => nil
+    # nil, 'none' or 0: no respawn, 'inf' or -1: infinite times, positive integer: try to respawn specified times only
+    config_param :child_respawn, :string, :default => nil
 
-  # 0: output logs for all of messages to emit
-  config_param :suppress_error_log_interval, :time, :default => 0
+    # 0: output logs for all of messages to emit
+    config_param :suppress_error_log_interval, :time, :default => 0
 
-  config_set_default :flush_interval, 1
+    config_set_default :flush_interval, 1
 
-  def configure(conf)
-    if tag_key = conf['tag_key']
-      # TODO obsoleted?
-      @in_tag_key = tag_key
-      @out_tag_key = tag_key
-    end
+    def configure(conf)
+      if tag_key = conf['tag_key']
+        # TODO obsoleted?
+        @in_tag_key = tag_key
+        @out_tag_key = tag_key
+      end
 
-    if time_key = conf['time_key']
-      # TODO obsoleted?
-      @in_time_key = time_key
-      @out_time_key = time_key
-    end
+      if time_key = conf['time_key']
+        # TODO obsoleted?
+        @in_time_key = time_key
+        @out_time_key = time_key
+      end
 
-    if time_format = conf['time_format']
-      # TODO obsoleted?
-      @in_time_format = time_format
-      @out_time_format = time_format
-    end
+      if time_format = conf['time_format']
+        # TODO obsoleted?
+        @in_time_format = time_format
+        @out_time_format = time_format
+      end
 
-    super
+      super
 
-    if localtime = conf['localtime']
-      @localtime = true
-    elsif utc = conf['utc']
-      @localtime = false
-    end
+      if localtime = conf['localtime']
+        @localtime = true
+      elsif utc = conf['utc']
+        @localtime = false
+      end
 
-    if !@tag && !@out_tag_key
-      raise ConfigError, "'tag' or 'out_tag_key' option is required on exec_filter output"
-    end
+      if !@tag && !@out_tag_key
+        raise ConfigError, "'tag' or 'out_tag_key' option is required on exec_filter output"
+      end
 
-    if @in_time_key
-      if f = @in_time_format
-        tf = TimeFormatter.new(f, @localtime)
-        @time_format_proc = tf.method(:format)
-      else
-        @time_format_proc = Proc.new {|time| time.to_s }
+      if @in_time_key
+        if f = @in_time_format
+          tf = TimeFormatter.new(f, @localtime)
+          @time_format_proc = tf.method(:format)
+        else
+          @time_format_proc = Proc.new {|time| time.to_s }
+        end
+      elsif @in_time_format
+        $log.warn "in_time_format effects nothing when in_time_key is not specified: #{conf}"
       end
-    elsif @in_time_format
-      $log.warn "in_time_format effects nothing when in_time_key is not specified: #{conf}"
-    end
 
-    if @out_time_key
-      if f = @out_time_format
-        @time_parse_proc = Proc.new {|str| Time.strptime(str, f).to_i }
-      else
-        @time_parse_proc = Proc.new {|str| str.to_i }
+      if @out_time_key
+        if f = @out_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
+      elsif @out_time_format
+        $log.warn "out_time_format effects nothing when out_time_key is not specified: #{conf}"
       end
-    elsif @out_time_format
-      $log.warn "out_time_format effects nothing when out_time_key is not specified: #{conf}"
-    end
 
-    if @remove_prefix
-      @removed_prefix_string = @remove_prefix + '.'
-      @removed_length = @removed_prefix_string.length
-    end
-    if @add_prefix
-      @added_prefix_string = @add_prefix + '.'
-    end
+      if @remove_prefix
+        @removed_prefix_string = @remove_prefix + '.'
+        @removed_length = @removed_prefix_string.length
+      end
+      if @add_prefix
+        @added_prefix_string = @add_prefix + '.'
+      end
 
-    case @in_format
-    when :tsv
-      if @in_keys.empty?
-        raise ConfigError, "in_keys option is required on exec_filter output for tsv in_format"
+      case @in_format
+      when :tsv
+        if @in_keys.empty?
+          raise ConfigError, "in_keys option is required on exec_filter output for tsv in_format"
+        end
+        @formatter = TSVFormatter.new(@in_keys)
+      when :json
+        @formatter = JSONFormatter.new
+      when :msgpack
+        @formatter = MessagePackFormatter.new
       end
-      @formatter = TSVFormatter.new(@in_keys)
-    when :json
-      @formatter = JSONFormatter.new
-    when :msgpack
-      @formatter = MessagePackFormatter.new
-    end
 
-    case @out_format
-    when :tsv
-      if @out_keys.empty?
-        raise ConfigError, "out_keys option is required on exec_filter output for tsv in_format"
+      case @out_format
+      when :tsv
+        if @out_keys.empty?
+          raise ConfigError, "out_keys option is required on exec_filter output for tsv in_format"
+        end
+        @parser = TSVParser.new(@out_keys, method(:on_message))
+      when :json
+        @parser = JSONParser.new(method(:on_message))
+      when :msgpack
+        @parser = MessagePackParser.new(method(:on_message))
       end
-      @parser = TSVParser.new(@out_keys, method(:on_message))
-    when :json
-      @parser = JSONParser.new(method(:on_message))
-    when :msgpack
-      @parser = MessagePackParser.new(method(:on_message))
-    end
 
-    @respawns = if @child_respawn.nil? or @child_respawn == 'none' or @child_respawn == '0'
-                  0
-                elsif @child_respawn == 'inf' or @child_respawn == '-1'
-                  -1
-                elsif @child_respawn =~ /^\d+$/
-                  @child_respawn.to_i
-                else
-                  raise ConfigError, "child_respawn option argument invalid: none(or 0), inf(or -1) or positive number"
-                end
-
-    @suppress_error_log_interval ||= 0
-    @next_log_time = Time.now.to_i
-  end
+      @respawns = if @child_respawn.nil? or @child_respawn == 'none' or @child_respawn == '0'
+                    0
+                  elsif @child_respawn == 'inf' or @child_respawn == '-1'
+                    -1
+                  elsif @child_respawn =~ /^\d+$/
+                    @child_respawn.to_i
+                  else
+                    raise ConfigError, "child_respawn option argument invalid: none(or 0), inf(or -1) or positive number"
+                  end
+
+      @suppress_error_log_interval ||= 0
+      @next_log_time = Time.now.to_i
+    end
 
-  def start
-    super
+    def start
+      super
 
-    @children = []
-    @rr = 0
-    begin
-      @num_children.times do
-        c = ChildProcess.new(@parser, @respawns)
-        c.start(@command)
-        @children << c
+      @children = []
+      @rr = 0
+      begin
+        @num_children.times do
+          c = ChildProcess.new(@parser, @respawns)
+          c.start(@command)
+          @children << c
+        end
+      rescue
+        shutdown
+        raise
       end
-    rescue
-      shutdown
-      raise
     end
-  end
 
-  def before_shutdown
-    super
-    $log.debug "out_exec_filter#before_shutdown called"
-    @children.each {|c|
-      c.finished = true
-    }
-    sleep 0.5  # TODO wait time before killing child process
-  end
-
-  def shutdown
-    super
+    def before_shutdown
+      super
+      $log.debug "out_exec_filter#before_shutdown called"
+      @children.each {|c|
+        c.finished = true
+      }
+      sleep 0.5  # TODO wait time before killing child process
+    end
 
-    @children.reject! {|c|
-      c.shutdown
-      true
-    }
-  end
+    def shutdown
+      super
 
-  def format_stream(tag, es)
-    if @remove_prefix
-      if (tag[0, @removed_length] == @removed_prefix_string and tag.length > @removed_length) or tag == @removed_prefix
-        tag = tag[@removed_length..-1] || ''
-      end
+      @children.reject! {|c|
+        c.shutdown
+        true
+      }
     end
 
-    out = ''
-
-    es.each {|time,record|
-      if @in_time_key
-        record[@in_time_key] = @time_format_proc.call(time)
-      end
-      if @in_tag_key
-        record[@in_tag_key] = tag
+    def format_stream(tag, es)
+      if @remove_prefix
+        if (tag[0, @removed_length] == @removed_prefix_string and tag.length > @removed_length) or tag == @removed_prefix
+          tag = tag[@removed_length..-1] || ''
+        end
       end
-      @formatter.call(record, out)
-    }
 
-    out
-  end
+      out = ''
 
-  def write(chunk)
-    r = @rr = (@rr + 1) % @children.length
-    @children[r].write chunk
-  end
-
-  class ChildProcess
-    attr_accessor :finished
+      es.each {|time,record|
+        if @in_time_key
+          record[@in_time_key] = @time_format_proc.call(time)
+        end
+        if @in_tag_key
+          record[@in_tag_key] = tag
+        end
+        @formatter.call(record, out)
+      }
 
-    def initialize(parser,respawns=0)
-      @pid = nil
-      @thread = nil
-      @parser = parser
-      @respawns = respawns
-      @mutex = Mutex.new
-      @finished = nil
+      out
     end
 
-    def start(command)
-      @command = command
-      @mutex.synchronize do
-        @io = IO.popen(command, "r+")
-        @pid = @io.pid
-        @io.sync = true
-        @thread = Thread.new(&method(:run))
-      end
-      @finished = false
+    def write(chunk)
+      r = @rr = (@rr + 1) % @children.length
+      @children[r].write chunk
     end
 
-    def kill_child(join_wait)
-      begin
-        Process.kill(:TERM, @pid)
-      rescue Errno::ESRCH
-        # Errno::ESRCH 'No such process', ignore
-        # child process killed by signal chained from fluentd process
+    class ChildProcess
+      attr_accessor :finished
+
+      def initialize(parser,respawns=0)
+        @pid = nil
+        @thread = nil
+        @parser = parser
+        @respawns = respawns
+        @mutex = Mutex.new
+        @finished = nil
       end
-      if @thread.join(join_wait)
-        # @thread successfully shutdown
-        return
+
+      def start(command)
+        @command = command
+        @mutex.synchronize do
+          @io = IO.popen(command, "r+")
+          @pid = @io.pid
+          @io.sync = true
+          @thread = Thread.new(&method(:run))
+        end
+        @finished = false
       end
-      begin
-        Process.kill(:KILL, @pid)
-      rescue Errno::ESRCH
-        # ignore if successfully killed by :TERM
+
+      def kill_child(join_wait)
+        begin
+          Process.kill(:TERM, @pid)
+        rescue Errno::ESRCH
+          # Errno::ESRCH 'No such process', ignore
+          # child process killed by signal chained from fluentd process
+        end
+        if @thread.join(join_wait)
+          # @thread successfully shutdown
+          return
+        end
+        begin
+          Process.kill(:KILL, @pid)
+        rescue Errno::ESRCH
+          # ignore if successfully killed by :TERM
+        end
+        @thread.join
       end
-      @thread.join
-    end
 
-    def shutdown
-      @finished = true
-      @mutex.synchronize do
-        kill_child(60) # TODO wait time
+      def shutdown
+        @finished = true
+        @mutex.synchronize do
+          kill_child(60) # TODO wait time
+        end
       end
-    end
 
-    def write(chunk)
-      begin
-        chunk.write_to(@io)
-      rescue Errno::EPIPE => e
-        # Broken pipe (child process unexpectedly exited)
-        $log.warn "exec_filter Broken pipe, child process maybe exited.", :command => @command
-        if try_respawn
-          retry # retry chunk#write_to with child respawned
-        else
-          raise e # to retry #write with other ChildProcess instance (when num_children > 1)
+      def write(chunk)
+        begin
+          chunk.write_to(@io)
+        rescue Errno::EPIPE => e
+          # Broken pipe (child process unexpectedly exited)
+          $log.warn "exec_filter Broken pipe, child process maybe exited.", :command => @command
+          if try_respawn
+            retry # retry chunk#write_to with child respawned
+          else
+            raise e # to retry #write with other ChildProcess instance (when num_children > 1)
+          end
         end
       end
-    end
 
-    def try_respawn
-      return false if @respawns == 0
-      @mutex.synchronize do
+      def try_respawn
         return false if @respawns == 0
+        @mutex.synchronize do
+          return false if @respawns == 0
 
-        kill_child(5) # TODO wait time
+          kill_child(5) # TODO wait time
 
-        @io = IO.popen(@command, "r+")
-        @pid = @io.pid
-        @io.sync = true
-        @thread = Thread.new(&method(:run))
+          @io = IO.popen(@command, "r+")
+          @pid = @io.pid
+          @io.sync = true
+          @thread = Thread.new(&method(:run))
 
-        @respawns -= 1 if @respawns > 0
+          @respawns -= 1 if @respawns > 0
+        end
+        $log.warn "exec_filter child process successfully respawned.", :command => @command, :respawns => @respawns
+        true
       end
-      $log.warn "exec_filter child process successfully respawned.", :command => @command, :respawns => @respawns
-      true
-    end
 
-    def run
-      @parser.call(@io)
-    rescue
-      $log.error "exec_filter thread unexpectedly failed with an error.", :command=>@command, :error=>$!.to_s
-      $log.warn_backtrace $!.backtrace
-    ensure
-      pid, stat = Process.waitpid2(@pid)
-      unless @finished
-        $log.error "exec_filter process unexpectedly exited.", :command=>@command, :ecode=>stat.to_i
-        unless @respawns == 0
-          $log.warn "exec_filter child process will respawn for next input data (respawns #{@respawns})."
+      def run
+        @parser.call(@io)
+      rescue
+        $log.error "exec_filter thread unexpectedly failed with an error.", :command=>@command, :error=>$!.to_s
+        $log.warn_backtrace $!.backtrace
+      ensure
+        pid, stat = Process.waitpid2(@pid)
+        unless @finished
+          $log.error "exec_filter process unexpectedly exited.", :command=>@command, :ecode=>stat.to_i
+          unless @respawns == 0
+            $log.warn "exec_filter child process will respawn for next input data (respawns #{@respawns})."
+          end
         end
       end
     end
-  end
 
-  class Formatter
-  end
-
-  class TSVFormatter < Formatter
-    def initialize(in_keys)
-      @in_keys = in_keys
-      super()
+    class Formatter
     end
 
-    def call(record, out)
-      last = @in_keys.length-1
-      for i in 0..last
-        key = @in_keys[i]
-        out << record[key].to_s
-        out << "\t" if i != last
+    class TSVFormatter < Formatter
+      def initialize(in_keys)
+        @in_keys = in_keys
+        super()
       end
-      out << "\n"
-    end
-  end
 
-  class JSONFormatter < Formatter
-    def call(record, out)
-      out << Yajl.dump(record) << "\n"
+      def call(record, out)
+        last = @in_keys.length-1
+        for i in 0..last
+          key = @in_keys[i]
+          out << record[key].to_s
+          out << "\t" if i != last
+        end
+        out << "\n"
+      end
     end
-  end
 
-  class MessagePackFormatter < Formatter
-    def call(record, out)
-      record.to_msgpack(out)
+    class JSONFormatter < Formatter
+      def call(record, out)
+        out << Yajl.dump(record) << "\n"
+      end
     end
-  end
 
-  def on_message(record)
-    if val = record.delete(@out_time_key)
-      time = @time_parse_proc.call(val)
-    else
-      time = Engine.now
+    class MessagePackFormatter < Formatter
+      def call(record, out)
+        record.to_msgpack(out)
+      end
     end
 
-    if val = record.delete(@out_tag_key)
-      tag = if @add_prefix
-              @added_prefix_string + val
-            else
-              val
-            end
-    else
-      tag = @tag
-    end
+    def on_message(record)
+      if val = record.delete(@out_time_key)
+        time = @time_parse_proc.call(val)
+      else
+        time = Engine.now
+      end
 
-    Engine.emit(tag, time, record)
+      if val = record.delete(@out_tag_key)
+        tag = if @add_prefix
+                @added_prefix_string + val
+              else
+                val
+              end
+      else
+        tag = @tag
+      end
 
-  rescue
-    if @suppress_error_log_interval == 0 || Time.now.to_i > @next_log_time
-      $log.error "exec_filter failed to emit", :error=>$!.to_s, :error_class=>$!.class.to_s, :record=>Yajl.dump(record)
-      $log.warn_backtrace $!.backtrace
-      @next_log_time = Time.now.to_i + @suppress_error_log_interval
-    end
-  end
+      Engine.emit(tag, time, record)
 
-  class Parser
-    def initialize(on_message)
-      @on_message = on_message
+    rescue
+      if @suppress_error_log_interval == 0 || Time.now.to_i > @next_log_time
+        $log.error "exec_filter failed to emit", :error=>$!.to_s, :error_class=>$!.class.to_s, :record=>Yajl.dump(record)
+        $log.warn_backtrace $!.backtrace
+        @next_log_time = Time.now.to_i + @suppress_error_log_interval
+      end
     end
-  end
 
-  class TSVParser < Parser
-    def initialize(out_keys, on_message)
-      @out_keys = out_keys
-      super(on_message)
+    class Parser
+      def initialize(on_message)
+        @on_message = on_message
+      end
     end
 
-    def call(io)
-      io.each_line(&method(:each_line))
-    end
+    class TSVParser < Parser
+      def initialize(out_keys, on_message)
+        @out_keys = out_keys
+        super(on_message)
+      end
 
-    def each_line(line)
-      line.chomp!
-      vals = line.split("\t")
+      def call(io)
+        io.each_line(&method(:each_line))
+      end
+
+      def each_line(line)
+        line.chomp!
+        vals = line.split("\t")
 
-      record = Hash[@out_keys.zip(vals)]
+        record = Hash[@out_keys.zip(vals)]
 
-      @on_message.call(record)
+        @on_message.call(record)
+      end
     end
-  end
 
-  class JSONParser < Parser
-    def call(io)
-      y = Yajl::Parser.new
-      y.on_parse_complete = @on_message
-      y.parse(io)
+    class JSONParser < Parser
+      def call(io)
+        y = Yajl::Parser.new
+        y.on_parse_complete = @on_message
+        y.parse(io)
+      end
     end
-  end
 
-  class MessagePackParser < Parser
-    def call(io)
-      @u = MessagePack::Unpacker.new(io)
-      begin
-        @u.each(&@on_message)
-      rescue EOFError
+    class MessagePackParser < Parser
+      def call(io)
+        @u = MessagePack::Unpacker.new(io)
+        begin
+          @u.each(&@on_message)
+        rescue EOFError
+        end
       end
     end
   end
 end
 
-
-end
-