em-syslog-logger 0.0.1 → 0.0.3

data/lib/em-syslog.rb

@@ -1,220 +1,29 @@
 
 require 'socket'
-require 'rubygems'
 require 'eventmachine'
+require 'em-syslog/syslog.rb'
+require 'em-syslog/connection_tcp.rb'
+require 'em-syslog/connection_udp.rb'
+require 'em-syslog/connection_unix.rb'
+require 'em-syslog/logger.rb'
 
 module EventMachine
   module Syslog
-    # THIEVERY: http://github.com/kpumuk/ruby_syslog
-    SEVERITIES = {
-      :emergency => 0, # system is unusable
-      :alert => 1, # action must be taken immediately
-      :critical => 2, # critical conditions
-      :error => 3, # error conditions
-      :warning => 4, # warning conditions
-      :notice => 5, # normal but significant condition
-      :informational => 6, # informational messages
-      :info => 6, # informational messages (short name for the previous)
-      :debug => 7 # debug-level messages
-    }
-    # THIEVERY: http://github.com/kpumuk/ruby_syslog
-    FACILITIES = {
-      :kernel => 0, # kernel messages
-      :user_level => 1, # user-level messages
-      :mail => 2, # mail system
-      :daemons => 3, # system daemons
-      :security => 4, # security/authorization messages
-      :internal => 5, # messages generated internally by syslogd
-      :printer => 6, # line printer subsystem
-      :network => 7, # network news subsystem
-      :uucp => 8, # UUCP subsystem
-      :clock => 9, # clock daemon
-      :security1 => 10, # security/authorization messages
-      :ftp => 11, # FTP daemon
-      :ntp => 12, # NTP subsystem
-      :log_audit => 13, # log audit
-      :log_alert => 14, # log alert
-      :clock1 => 15, # clock daemon
-      :local0 => 16, # local use 0
-      :local1 => 17, # local use 1
-      :local2 => 18, # local use 2
-      :local3 => 19, # local use 3
-      :local4 => 20, # local use 4
-      :local5 => 21, # local use 5
-      :local6 => 22, # local use 6
-      :local7 => 23 # local use 7
-    }
+    ##
+    # Candy for creating a new Logger object or returned a cached one
 
     def self.logger( *a)
       EventMachine::Logger.new( *a)
     end
-
-    module ConnectionUDP
-      # EM does not support doing UDP over unix domain sockets, so we have to manually handle it.
-      def self.create_unix
-        ::Socket.new(
-          ::Socket::PF_UNIX,
-          ::Socket::SOCK_DGRAM
-        )
-      end
-
-      def self.pack_unix( path)
-        ::Socket.pack_sockaddr_un( path)
-      end
-
-      def setup( host, port, unix_connection=nil)
-        @host = unix_connection.nil? ? host : ::Socket.pack_sockaddr_un( host)
-        @port = port
-        @unix_connection = unix_connection
-        @unix_connection.connect( @host) unless @unix_connection.nil?
-      end
-
-      # Should not be needed
-      def notify_readable
-        read_packet
-      end
-
-      def read_packet
-        data, sender = @unix_connection.recvfrom( 1024)
-        true
-      end
-
-      def send_msg( msg)
-        if @unix_connection.nil?
-          send_datagram( msg, @host, @port)
-        else
-          @unix_connection.send( msg, 0)
-        end
-      end
-    end
-
-    module ConnectionTCP
-      def setup( host, port)
-        @host = host
-        @port = port
-        @queue = Array.new
-        @connected = false
-      end
-
-      def post_init
-        @connected = true
-        @queue.size.times {
-          send_msg( @queue.shift)
-        }
-      end
-
-      def send_msg( msg)
-        if @connected
-          send_data( msg)
-        else
-          @queue.push( msg)
-        end
-      end
-
-      def unbind
-        @connected = false
-        reconnect( @host, @port)
-      end
-    end
-  end
-
-  class Logger
-    @@connection_cache = Hash.new
-    attr_reader :idenity, :resource
-
-    # Yup hack new class method for cache candy
-    def self.new( idenity, resource="unix://dev/log")
-      # See if we have a connection already in our cache      
-      key = self.mk_cache_index_key( idenity, resource)
-      return @@connection_cache[key] if @@connection_cache.has_key? key and @@connection_cache[key].error? == false
-
-      # Otherwise allocate a new object to do the work
-      instance = self.allocate
-      instance.send( :initialize, idenity, resource)
-      @@connection_cache[key] = instance
-    end
-
-    def initialize( idenity, resource)
-      @idenity = idenity.to_s + "[" + Process.pid.to_s + "]"
-      @resource = resource
-      resource = self.class.parse_resource( resource)
-
-      case resource[0]
-      when :unix
-        # need better checking here
-        raise "unix domain socket #{resource[1]} does not exist!" unless ::File.exists?( resource[1])
-        @connection = Syslog::ConnectionUDP.create_unix
-        resource << @connection
-        @connection = EM.watch( @connection, Syslog::ConnectionUDP)
-      when :tcp
-        @connection = EM.connect( resource[1], resource[2], Syslog::ConnectionTCP)
-      else
-        @connection = EM.open_datagram_socket( '0.0.0.0', 0, Syslog::ConnectionUDP)
-      end
-      raise "unable to create connection" if @connection.nil?
-      resource.shift
-      @connection.setup( *resource)
-    end
-
-    def log( msg, facility, severity, debug=true)
-      m = String.new
-      if debug
-        raise "Invalid log severity!" unless Syslog::SEVERITIES.has_key? severity
-        raise "Invalid log facility!" unless Syslog::FACILITIES.has_key? facility
-      end
-      m += "<" + self.class.class_variable_get("@@syskey_#{facility}_#{severity}".to_sym).to_s + ">"
-      m += self.class.timestamp + " " + ::Socket.gethostname + " #{@idenity} " + msg.to_s
-      @connection.send_msg( m)
-    end
-
-    #Meta program our facility/severity keys and methods
-    Syslog::FACILITIES.each {|facility,facility_int|
-      Syslog::SEVERITIES.each {|severity,severity_int|
-        define_method( "#{facility}_#{severity}".to_sym) do |msg|
-          log( msg, facility, severity, false)
-        end
-        self.class_variable_set("@@syskey_#{facility}_#{severity}".to_sym, (facility_int * 8 + severity_int))
-      }
-    }
-
-    private
-    def self.timestamp( time=Time.now)
-      day = time.strftime("%d")
-      day = day.sub(/^0/, ' ') if day =~ /^0\d/
-      time.strftime("%b #{day} %H:%M:%S")
-    end
-
-    # Likely not the fastest and best way to make a cache index
-    def self.mk_cache_index_key( idenity, resource)
-     idenity.to_s + resource.split(':').each {|i| i.gsub(/\./,'') }.join
-    end
-
-    def self.parse_resource( resource)
-      split_point = resource.index(':')
-      answer = [ resource[0..(split_point-1)].to_sym, resource[(split_point+1)..-1]]
-      split_point = answer[1].index(':')
-      if split_point.nil? == false and split_point > 0
-        answer << answer[1][(split_point+1)..-1].to_i
-        answer[1] = answer[1][0..(split_point-1)]
-      elsif split_point.nil? and answer[0] != :unix
-        answer << 514
-      elsif split_point.nil? == false
-        raise "Resource parse error"
-      else
-        answer[1].slice!(0)
-        answer << nil
-      end
-      answer
-    end
   end
-end 
+end
 
 if __FILE__ == $0
   EM.run {
     EM.kqueue if EM.kqueue?
     EM.epoll if EM.epoll?
 
-    logger = EM::Syslog.logger( "em-syslog-test")
+    logger = EM::Syslog.logger( {:idenity => "em-syslog-test" })
     EM.next_tick {
       logger.log( "TEST INFO", :daemons, :info)
       logger.mail_error( "MAIL ERROR")
@@ -222,3 +31,5 @@ if __FILE__ == $0
   }
 end
 
+require 'em-syslog/version.rb'
+

data/lib/em-syslog/connection_tcp.rb

@@ -0,0 +1,84 @@
+
+module EventMachine
+  module Syslog
+    ##
+    # Our module to pass to EventMachine to create the connection handler
+
+    module ConnectionTCP
+      DEFAULTS = {:queue_max_size => 500,
+                  :queue_batch_send => 20,
+                  :on_hangup => nil,
+                  :reconnect => true
+                 }
+      ##
+      # setup our connection with remote/local information, with a hash config merged against ConnectionTCP::DEFAULTS
+
+      def setup( host, port, config={})
+        config = DEFAULTS.merge( config)
+        @host = host
+        @port = port
+        @do_reconnect = config[:on_hangup]
+        @reconnect = config[:reconnect]
+        @queue = Array.new
+        @connected = false
+        true
+      end
+
+      ##
+      # we got our connection, time to start sending any items we have queued up
+
+      def post_init
+        @connected = true
+        queue_send_batch
+      end
+
+      ##
+      # queue messages if we are not connected.
+
+      def send_msg( msg)
+        if @connected
+          send_data( msg)
+        else
+          queue_push( msg)
+        end
+      end
+
+      ##
+      # Do you want to be told when it disconnects and/or do you want to reconnect right away config[:reconnect] = true 
+      #  passing config[:on_hangup] provide a proc. 
+
+      def unbind
+        @connected = false
+        reconnect( @host, @port) if @do_reconnect
+        @on_hangup.call unless @on_hangup.nil?
+      end
+
+      private
+      ##
+      # Rotate out old messages for newer messages.
+
+      def queue_push( msg)
+        old_message = (@queue.length >= @queue_max_size) ? @queue.shift : nil
+        @queue << msg
+        old_message
+      end
+
+      ##
+      # loop batch send on each tick sending at least config[:queue_batch_size] times
+
+      def queue_send_batch
+        run_list = @queue.slice!(0..@queue_batch_size)
+        run_list.each {|msg|
+          send_msg( msg)
+        }
+        unless @queue.empty?
+          EM.next_tick {
+            queue_send_batch
+          }
+        end
+        true
+      end
+    end
+  end
+end 
+

data/lib/em-syslog/connection_udp.rb

@@ -0,0 +1,37 @@
+
+module EventMachine
+  module Syslog
+    ##
+    # Our module to pass to EventMachine to handle the UDP Connection over IP Socket
+
+    module ConnectionUDP
+
+      def setup( host, port)
+        @host = host
+        @port = port
+      end
+
+      ##
+      # Should not be needed
+
+      def notify_readable
+        read_packet
+      end
+
+      ##
+      # Should not be needed
+
+      def read_packet
+        data, sender = @unix_connection.recvfrom( 1024)
+        true
+      end
+
+      ##
+      # Handle no buffering just send it
+
+      def send_msg( msg)
+        send_datagram( msg, @host, @port)
+      end
+    end
+  end
+end 

data/lib/em-syslog/connection_unix.rb

@@ -0,0 +1,41 @@
+
+module EventMachine
+  module Syslog
+    module ConnectionUDP
+      ##
+      # Our module to pass to EventMachine to handle the UDP Connection over IPC Socket
+
+      module UNIX
+        include ConnectionUDP
+        ##
+        # we also have to code around the difference of Socket.new in ruby 1.8 and 1.9
+
+        def self.create_unix
+          case RUBY_VERSION.split('.')[1].to_i
+          when 8
+            ::Socket.new(
+              ::Socket::PF_UNIX,
+              ::Socket::SOCK_DGRAM,
+              0
+            )
+          else
+            ::Socket.new(
+              ::Socket::PF_UNIX,
+              ::Socket::SOCK_DGRAM
+            )
+          end
+        end
+
+        def setup( ipc, path)
+          ipc_address = ::Socket.pack_sockaddr_un( path)
+          @unix_connection = ipc
+          @unix_connection.connect( ipc_address)
+        end
+
+        def send_msg( msg)
+          @unix_connection.send( msg, 0)
+        end
+      end
+    end
+  end
+end

data/lib/em-syslog/logger.rb

@@ -0,0 +1,150 @@
+
+module EventMachine
+  ##
+  # Generic Logger Class, providing simple to use statements
+  # auto fills in the most likely config DEFAULTS
+
+  class Logger
+    @@connection_cache = Hash.new
+    begin
+      @@hostname = ::Socket.gethostname.split('.')[0]
+    rescue Exception
+      @@hostname = 'localhost'
+    end
+    attr_reader :idenity, :resource, :include_hostname
+    DEFAULTS = {:idenity => $PROGRAM_NAME,
+                :include_hostname => false,
+                :resource => "udp:/dev/log"
+               }
+    ##
+    # hack new class method for caching connections, making it safe to keep variables out of scope.
+
+    def self.new( config = {})
+      config = DEFAULTS.merge config
+      # See if we have a connection already in our cache      
+      key = self.mk_cache_index_key( config[:idenity], config[:resource])
+      return @@connection_cache[key] if @@connection_cache.has_key? key and @@connection_cache[key].error? == false
+
+      # Otherwise allocate a new object to do the work
+      instance = self.allocate
+      instance.send( :initialize, config)
+      @@connection_cache[key] = instance
+    end
+
+    ##
+    # save out needed information from config, and start up the connection
+    TYPE = 0
+    HOST = 1
+    IPC = 1
+    PORT = 2
+
+    def initialize( config)
+      @idenity = config[:idenity].to_s + "[" + Process.pid.to_s + "]"
+      @resource = config[:resource].dup
+      @include_hostname = config[:include_hostname]
+      resource = self.class.parse_resource( config[:resource])
+
+      @connection = nil
+      if resource[TYPE] == :tcp
+        # resource[PORT] should return nil considering we only define a pair (resource_type|path)
+        @connection = EM.connect( resource[HOST], resource[PORT], Syslog::ConnectionTCP)
+        raise "unable to create connection" if @connection.nil?
+        @connection.setup( resource[HOST], resource[PORT])
+      elsif resource.length == 3
+        @connection = EM.open_datagram_socket( '0.0.0.0', 0, Syslog::ConnectionUDP)
+        raise "unable to create connection" if @connection.nil?
+        @connection.setup( resource[HOST], resource[PORT])
+      else
+        # need better checking here
+        raise "unix domain socket #{resource[IPC]} does not exist!" unless ::File.exists?( resource[IPC])
+        c = Syslog::ConnectionUDP::UNIX.create_unix
+        @connection = EM.watch( c, Syslog::ConnectionUDP::UNIX)
+        raise "unable to create connection" if @connection.nil?
+        @connection.setup( c, resource[IPC]) 
+      end
+    end
+
+    ##
+    # When called directly we need to make sure we were given valid facilities and severity
+
+    def log( msg, facility, severity)
+      raise "Invalid log severity!" unless Syslog::SEVERITIES.has_key? severity
+      raise "Invalid log facility!" unless Syslog::FACILITIES.has_key? facility
+      send_log( msg, facility, severity)
+    end
+
+    ##
+    #Meta program our facility/severity keys and methods
+
+    Syslog::FACILITIES.each {|facility,facility_int|
+      Syslog::SEVERITIES.each {|severity,severity_int|
+        define_method( "#{facility}_#{severity}".to_sym) do |msg|
+          send_log( msg, facility, severity)
+        end
+        class_variable_set("@@syskey_#{facility}_#{severity}".to_sym, (facility_int * 8 + severity_int))
+      }
+    }
+    Syslog::SEVERITIES.each {|severity,severity_int|
+      define_method( severity) do |msg,facility|
+        send_log( msg, ((facility.nil?) ? :daemons : facility), severity)
+      end
+    }
+
+    ##
+    # you must fix up the timestamp so that a space is injected in place of a leading 0
+    # - returns "Dec  6 12:12:12"
+
+    def self.timestamp( time=Time.now)
+      day = time.strftime("%d")
+      day = day.sub(/^0/, ' ') if day =~ /^0\d/
+      time.strftime("%b #{day} %H:%M:%S")
+    end
+
+    private
+    ##
+    # Format and send message to syslog
+
+    def send_log( msg, facility, severity)
+      m = String.new
+      m += "<" + self.class.send( :class_variable_get, "@@syskey_#{facility}_#{severity}".to_sym).to_s + ">"
+      m += self.class.timestamp + " "
+      m += @@hostname + " " if include_hostname
+      m += "#{@idenity}: " + msg.to_s
+      @connection.send_msg( m)
+    end
+
+    ##
+    # Likely not the fastest and best way to make a cache index
+    # - returns "#{idenitiy}#{ip|hostname|path.without_dots}"
+
+    def self.mk_cache_index_key( idenity, resource)
+     idenity.to_s + resource.split(':').each {|i| i.gsub(/\./,'') }.join
+    end
+
+    ##
+    # Likely not the fastest and best way to parse the syslog resource idenity.
+    # unix will always return a set length of 2 and host/port at length 3
+    # - returns [ resource_type (:tcp|:udp), ipc_path|ip_address|hostname [, port]]
+    
+    def self.parse_resource( resource)
+      split_point = resource.index(':')
+      resource_type = resource[0..(split_point-1)].to_sym
+      resource = resource[(split_point+1)..-1]
+      if resource_type != :tcp and resource_type != :udp
+        raise "Invalid resource syntax, protocol must be :tcp|:udp"
+      elsif resource[0..1] == "//"
+        resource_parts = resource.split('/')
+        target_parts = resource_parts[2].split(':')
+        raise "Invalid resource syntax: #{resource}" if target_parts.length > 2 or resource_parts.length > 3
+        target_parts << 514 if target_parts.length == 1
+        target_parts.unshift resource_type
+      elsif resource[0,1] == "/"
+        target_parts = [ resource_type, resource]
+      else
+        raise "Invalid resource syntax: can't detect connection type #{resource}"
+      end
+      target_parts
+    end
+  end
+end 
+

data/lib/em-syslog/syslog.rb

@@ -0,0 +1,49 @@
+
+module EventMachine
+  module Syslog
+    ##
+    # THIEVERY: http://github.com/kpumuk/ruby_syslog
+
+    SEVERITIES = {
+      :emergency => 0, # system is unusable
+      :alert => 1, # action must be taken immediately
+      :critical => 2, # critical conditions
+      :error => 3, # error conditions
+      :warning => 4, # warning conditions
+      :notice => 5, # normal but significant condition
+      :informational => 6, # informational messages
+      :info => 6, # informational messages (short name for the previous)
+      :debug => 7 # debug-level messages
+    }
+
+    ##
+    # THIEVERY: http://github.com/kpumuk/ruby_syslog
+
+    FACILITIES = {
+      :kernel => 0, # kernel messages
+      :user_level => 1, # user-level messages
+      :mail => 2, # mail system
+      :daemons => 3, # system daemons
+      :security => 4, # security/authorization messages
+      :internal => 5, # messages generated internally by syslogd
+      :printer => 6, # line printer subsystem
+      :network => 7, # network news subsystem
+      :uucp => 8, # UUCP subsystem
+      :clock => 9, # clock daemon
+      :security1 => 10, # security/authorization messages
+      :ftp => 11, # FTP daemon
+      :ntp => 12, # NTP subsystem
+      :log_audit => 13, # log audit
+      :log_alert => 14, # log alert
+      :clock1 => 15, # clock daemon
+      :local0 => 16, # local use 0
+      :local1 => 17, # local use 1
+      :local2 => 18, # local use 2
+      :local3 => 19, # local use 3
+      :local4 => 20, # local use 4
+      :local5 => 21, # local use 5
+      :local6 => 22, # local use 6
+      :local7 => 23 # local use 7
+    }
+  end
+end

data/lib/em-syslog/version.rb

@@ -0,0 +1,5 @@
+module EventMachine
+  module Syslog
+    VERSION = "0.0.3"
+  end
+end

metadata

@@ -5,8 +5,8 @@ version: !ruby/object:Gem::Version
   segments: 
   - 0
   - 0
-  - 1
-  version: 0.0.1
+  - 3
+  version: 0.0.3
 platform: ruby
 authors: 
 - Digital Akasha
@@ -40,6 +40,12 @@ extensions: []
 extra_rdoc_files: []
 
 files: 
+- lib/em-syslog/connection_tcp.rb
+- lib/em-syslog/connection_udp.rb
+- lib/em-syslog/connection_unix.rb
+- lib/em-syslog/logger.rb
+- lib/em-syslog/syslog.rb
+- lib/em-syslog/version.rb
 - lib/em-syslog.rb
 has_rdoc: true
 homepage: https://github.com/tormenta/em-syslog