logstash-lib 1.3.2

data/lib/logstash/outputs/stdout.rb

@@ -0,0 +1,53 @@
+# encoding: utf-8
+require "logstash/outputs/base"
+require "logstash/namespace"
+
+class LogStash::Outputs::Stdout < LogStash::Outputs::Base
+  begin
+     require "ap"
+  rescue LoadError
+  end
+
+  config_name "stdout"
+  milestone 3
+  
+  default :codec, "line"
+
+  # Enable debugging. Tries to pretty-print the entire event object.
+  config :debug, :validate => :boolean, :default => false
+
+  # Debug output format: ruby (default), json
+  config :debug_format, :default => "ruby", :validate => ["ruby", "dots", "json"], :deprecated => true
+
+  # The message to emit to stdout.
+  config :message, :validate => :string, :deprecated => "You can use the 'line' codec instead. For example: output { stdout { codec => line { format => \"%{somefield} your message\" } } }"
+
+  public
+  def register
+    if @debug
+      require "logstash/codecs/rubydebug"
+      require "logstash/codecs/dots"
+      require "logstash/codecs/json"
+      case @debug_format
+        when "ruby"; @codec = LogStash::Codecs::RubyDebug.new
+        when "json"; @codec = LogStash::Codecs::JSON.new
+        when "dots"; @codec = LogStash::Codecs::Dots.new
+      end
+    elsif @message
+      @codec = LogStash::Codecs::Line.new("format" => @message)
+    end
+    @codec.on_event do |event|
+      $stdout.write(event)
+    end
+  end
+
+  def receive(event)
+    return unless output?(event)
+    if event == LogStash::SHUTDOWN
+      finished
+      return
+    end
+    @codec.encode(event)
+  end
+
+end # class LogStash::Outputs::Stdout

data/lib/logstash/outputs/stomp.rb

@@ -0,0 +1,67 @@
+# encoding: utf-8
+require "logstash/outputs/base"
+require "logstash/namespace"
+
+class LogStash::Outputs::Stomp < LogStash::Outputs::Base
+  config_name "stomp"
+  milestone 2
+
+  # The address of the STOMP server.
+  config :host, :validate => :string, :required => true
+
+  # The port to connect to on your STOMP server.
+  config :port, :validate => :number, :default => 61613
+
+  # The username to authenticate with.
+  config :user, :validate => :string, :default => ""
+
+  # The password to authenticate with.
+  config :password, :validate => :password, :default => ""
+
+  # The destination to read events from. Supports string expansion, meaning
+  # %{foo} values will expand to the field value.
+  #
+  # Example: "/topic/logstash"
+  config :destination, :validate => :string, :required => true
+
+  # The vhost to use
+  config :vhost, :validate => :string, :default => nil
+
+  # Enable debugging output?
+  config :debug, :validate => :boolean, :default => false
+
+  private
+  def connect
+    begin
+      @client.connect
+      @logger.debug("Connected to stomp server") if @client.connected?
+    rescue => e
+      @logger.debug("Failed to connect to stomp server, will retry",
+                    :exception => e, :backtrace => e.backtrace)
+      sleep 2
+      retry
+    end
+  end
+
+
+  public
+  def register
+    require "onstomp"
+    @client = OnStomp::Client.new("stomp://#{@host}:#{@port}", :login => @user, :passcode => @password.value)
+    @client.host = @vhost if @vhost
+
+    # Handle disconnects
+    @client.on_connection_closed {
+      connect
+    }
+    
+    connect
+  end # def register
+  
+  def receive(event)
+      return unless output?(event)
+
+      @logger.debug(["stomp sending event", { :host => @host, :event => event }])
+      @client.send(event.sprintf(@destination), event.to_json)
+  end # def receive
+end # class LogStash::Outputs::Stomp

data/lib/logstash/outputs/syslog.rb

@@ -0,0 +1,145 @@
+# encoding: utf-8
+require "logstash/outputs/base"
+require "logstash/namespace"
+require "date"
+
+# Send events to a syslog server.
+#
+# You can send messages compliant with RFC3164 or RFC5424
+# UDP or TCP syslog transport is supported
+class LogStash::Outputs::Syslog < LogStash::Outputs::Base
+  config_name "syslog"
+  milestone 1
+
+  FACILITY_LABELS = [
+    "kernel",
+    "user-level",
+    "mail",
+    "daemon",
+    "security/authorization",
+    "syslogd",
+    "line printer",
+    "network news",
+    "uucp",
+    "clock",
+    "security/authorization",
+    "ftp",
+    "ntp",
+    "log audit",
+    "log alert",
+    "clock",
+    "local0",
+    "local1",
+    "local2",
+    "local3",
+    "local4",
+    "local5",
+    "local6",
+    "local7",
+  ]
+
+  SEVERITY_LABELS = [
+    "emergency",
+    "alert",
+    "critical",
+    "error",
+    "warning",
+    "notice",
+    "informational",
+    "debug",
+  ]
+
+  # syslog server address to connect to
+  config :host, :validate => :string, :required => true
+  
+  # syslog server port to connect to
+  config :port, :validate => :number, :required => true
+
+  # syslog server protocol. you can choose between udp and tcp
+  config :protocol, :validate => ["tcp", "udp"], :default => "udp"
+
+  # facility label for syslog message
+  config :facility, :validate => FACILITY_LABELS, :required => true
+
+  # severity label for syslog message
+  config :severity, :validate => SEVERITY_LABELS, :required => true
+
+  # source host for syslog message
+  config :sourcehost, :validate => :string, :default => "%{host}"
+
+  # timestamp for syslog message
+  config :timestamp, :validate => :string, :default => "%{@timestamp}", :deprecated => "This setting is no longer necessary. The RFC setting will determine what time format is used."
+
+  # application name for syslog message
+  config :appname, :validate => :string, :default => "LOGSTASH"
+
+  # process id for syslog message
+  config :procid, :validate => :string, :default => "-"
+ 
+  # message id for syslog message
+  config :msgid, :validate => :string, :default => "-"
+
+  # syslog message format: you can choose between rfc3164 or rfc5424
+  config :rfc, :validate => ["rfc3164", "rfc5424"], :default => "rfc3164"
+
+  
+  public
+  def register
+      @client_socket = nil
+  end
+
+  private
+  def udp?
+    @protocol == "udp"
+  end
+
+  private
+  def rfc3164?
+    @rfc == "rfc3164"
+  end 
+
+  private
+  def connect
+    if udp?
+        @client_socket = UDPSocket.new
+        @client_socket.connect(@host, @port)
+    else
+        @client_socket = TCPSocket.new(@host, @port)
+    end
+  end
+
+  public
+  def receive(event)
+    return unless output?(event)
+
+    appname = event.sprintf(@appname)
+    procid = event.sprintf(@procid)
+    sourcehost = event.sprintf(@sourcehost)
+
+    facility_code = FACILITY_LABELS.index(@facility)
+
+    severity_code = SEVERITY_LABELS.index(@severity)
+
+    priority = (facility_code * 8) + severity_code
+
+    if rfc3164?
+      timestamp = event.sprintf("%{+MMM dd HH:mm:ss}")
+      syslog_msg = "<"+priority.to_s()+">"+timestamp+" "+sourcehost+" "+appname+"["+procid+"]: "+event["message"]
+    else
+      msgid = event.sprintf(@msgid)
+      timestamp = event.sprintf("%{+YYYY-MM-dd'T'HH:mm:ss.SSSZ}")
+      syslog_msg = "<"+priority.to_s()+">1 "+timestamp+" "+sourcehost+" "+appname+" "+procid+" "+msgid+" - "+event["message"]
+    end
+
+    begin
+      connect unless @client_socket
+      @client_socket.write(syslog_msg + "\n")
+    rescue => e
+      @logger.warn(@protocol+" output exception", :host => @host, :port => @port,
+                 :exception => e, :backtrace => e.backtrace)
+      @client_socket.close rescue nil
+      @client_socket = nil
+    end
+  end
+end
+

data/lib/logstash/outputs/tcp.rb

@@ -0,0 +1,145 @@
+# encoding: utf-8
+require "logstash/outputs/base"
+require "logstash/namespace"
+require "thread"
+
+# Write events over a TCP socket.
+#
+# Each event json is separated by a newline.
+#
+# Can either accept connections from clients or connect to a server,
+# depending on `mode`.
+class LogStash::Outputs::Tcp < LogStash::Outputs::Base
+
+  config_name "tcp"
+  milestone 2
+
+  default :codec, "json"
+
+  # When mode is `server`, the address to listen on.
+  # When mode is `client`, the address to connect to.
+  config :host, :validate => :string, :required => true
+
+  # When mode is `server`, the port to listen on.
+  # When mode is `client`, the port to connect to.
+  config :port, :validate => :number, :required => true
+  
+  # When connect failed,retry interval in sec.
+  config :reconnect_interval, :validate => :number, :default => 10
+
+  # Mode to operate in. `server` listens for client connections,
+  # `client` connects to a server.
+  config :mode, :validate => ["server", "client"], :default => "client"
+
+  # The format to use when writing events to the file. This value
+  # supports any string and can include %{name} and other dynamic
+  # strings.
+  #
+  # If this setting is omitted, the full json representation of the
+  # event will be written as a single line.
+  config :message_format, :validate => :string, :deprecated => true
+
+  class Client
+    public
+    def initialize(socket, logger)
+      @socket = socket
+      @logger = logger
+      @queue  = Queue.new
+    end
+
+    public
+    def run
+      loop do
+        begin
+          @socket.write(@queue.pop)
+        rescue => e
+          @logger.warn("tcp output exception", :socket => @socket,
+                       :exception => e)
+          break
+        end
+      end
+    end # def run
+
+    public
+    def write(msg)
+      @queue.push(msg)
+    end # def write
+  end # class Client
+
+  public
+  def register
+    require "stud/try"
+    if server?
+      workers_not_supported
+
+      @logger.info("Starting tcp output listener", :address => "#{@host}:#{@port}")
+      @server_socket = TCPServer.new(@host, @port)
+      @client_threads = []
+
+      @accept_thread = Thread.new(@server_socket) do |server_socket|
+        loop do
+          client_thread = Thread.start(server_socket.accept) do |client_socket|
+            client = Client.new(client_socket, @logger)
+            Thread.current[:client] = client
+            client.run
+          end
+          @client_threads << client_thread
+        end
+      end
+
+      @codec.on_event do |payload|
+        @client_threads.each do |client_thread|
+          client_thread[:client].write(payload)
+        end
+        @client_threads.reject! {|t| !t.alive? }
+      end
+    else
+      client_socket = nil
+      @codec.on_event do |payload|
+        begin
+          client_socket = connect unless client_socket
+          r,w,e = IO.select([client_socket], [client_socket], [client_socket], nil)
+          # don't expect any reads, but a readable socket might
+          # mean the remote end closed, so read it and throw it away.
+          # we'll get an EOFError if it happens.
+          client_socket.sysread(16384) if r.any?
+
+          # Now send the payload
+          client_socket.syswrite(payload) if w.any?
+        rescue => e
+          @logger.warn("tcp output exception", :host => @host, :port => @port,
+                       :exception => e, :backtrace => e.backtrace)
+          client_socket.close rescue nil
+          client_socket = nil
+          sleep @reconnect_interval
+          retry
+        end
+      end
+    end
+  end # def register
+
+  private
+  def connect
+    Stud::try do
+      return TCPSocket.new(@host, @port)
+    end
+  end # def connect
+
+  private
+  def server?
+    @mode == "server"
+  end # def server?
+
+  public
+  def receive(event)
+    return unless output?(event)
+
+    #if @message_format
+      #output = event.sprintf(@message_format) + "\n"
+    #else
+      #output = event.to_hash.to_json + "\n"
+    #end
+    
+    @codec.encode(event)
+  end # def receive
+end # class LogStash::Outputs::Tcp

data/lib/logstash/outputs/udp.rb

@@ -0,0 +1,38 @@
+# encoding: utf-8
+require "logstash/outputs/base"
+require "logstash/namespace"
+require "socket"
+
+# Send events over UDP
+#
+# Keep in mind that UDP will lose messages.
+class LogStash::Outputs::UDP < LogStash::Outputs::Base
+  config_name "udp"
+  milestone 1
+  
+  default :codec, "json"
+
+  # The address to send messages to
+  config :host, :validate => :string, :required => true
+
+  # The port to send messages on
+  config :port, :validate => :number, :required => true
+
+  public
+  def register
+    @socket = UDPSocket.new
+    @codec.on_event do |payload|
+      @socket.send(payload, 0, @host, @port)
+    end
+  end
+
+  def receive(event)
+    return unless output?(event)
+    if event == LogStash::SHUTDOWN
+      finished
+      return
+    end
+    @codec.encode(event)
+  end
+
+end # class LogStash::Outputs::Stdout