analogger 0.5.0 → 0.9.1

data/{src/swiftcore/Analogger.rb → lib/swiftcore/Analogger.rb.orig}

@@ -2,6 +2,7 @@ require 'socket'
 begin
 	load_attempted ||= false
 	require 'eventmachine'
+	require 'benchmark'
 rescue LoadError => e
 	unless load_attempted
 		load_attempted = true
@@ -19,18 +20,25 @@ module Swiftcore
 		Cdaemonize = 'daemonize'.freeze
 		Cdefault = 'default'.freeze
 		Cdefault_log = 'default_log'.freeze
+		Cepoll = 'epoll'.freeze
 		Chost = 'host'.freeze
 		Cinterval = 'interval'.freeze
 		Ckey = 'key'.freeze
+		Ckqueue = 'kqueue'.freeze
+		Clevels = 'levels'.freeze
 		Clogfile = 'logfile'.freeze
 		Clogs = 'logs'.freeze
+		Cpidfile = 'pidfile'.freeze
 		Cport = 'port'.freeze
+		Croll = 'roll'.freeze
+		Croll_age = 'roll_age'.freeze
+		Croll_size = 'roll_size'.freeze
+		Croll_interval = 'roll_interval'.freeze
 		Csecret = 'secret'.freeze
 		Cservice = 'service'.freeze
-		Clevels = 'levels'.freeze
 		Csyncinterval = 'syncinterval'.freeze
-		Cpidfile = 'pidfile'.freeze
 		DefaultSeverityLevels = ['debug','info','warn','error','fatal'].inject({}){|h,k|h[k]=true;h}
+		TimeFormat = '%Y/%m/%d %H:%M:%S'.freeze
 
 		class NoPortProvided < Exception; def to_s; "The port to bind to was not provided."; end; end
 		class BadPort < Exception
@@ -41,7 +49,14 @@ module Swiftcore
 		 	def to_s; "The port provided (#{@port}) is invalid."; end
  		end
 
+		EXIT_SIGNALS = %w[INT TERM]
+		RELOAD_SIGNALS = %w[HUP]
+
 		class << self
+			def safe_trap(siglist, &operation)
+				(Signal.list.keys & siglist).each {|sig| trap(sig, &operation)}
+			end
+
 			def start(config,protocol = AnaloggerProtocol)
 				@config = config
 				daemonize if @config[Cdaemonize]
@@ -54,14 +69,22 @@ module Swiftcore
 				set_config_defaults
 				@rcount = 0
 				@wcount = 0
-				trap("INT") {cleanup;exit}
-				trap("TERM") {cleanup;exit}
-				trap("HUP") {cleanup;throw :hup}
+				safe_trap(EXIT_SIGNALS) {cleanup;exit}
+				safe_trap(RELOAD_SIGNALS) {cleanup;throw :hup}
+
+				if @config[Cepoll] or @config[Ckqueue]
+					EventMachine.epoll if @config[Cepoll]
+					EventMachine.kqueue if @config[Ckqueue]
+
+					EventMachine.set_descriptor_table_size(4096)
+				end
+
 				EventMachine.run {
 					EventMachine.start_server @config[Chost], @config[Cport], protocol
 					EventMachine.add_periodic_timer(1) {Analogger.update_now}
 					EventMachine.add_periodic_timer(@config[Cinterval]) {write_queue}
 					EventMachine.add_periodic_timer(@config[Csyncinterval]) {flush_queue}
+					EventMachine.add_periodic_timer(@config[Crollinterval]) {roll logs}
 				}
 			end
 
@@ -76,8 +99,8 @@ module Swiftcore
 				puts "Platform (#{RUBY_PLATFORM}) does not appear to support fork/setsid; skipping"
 			end
 
-			def new_log(facility = Cdefault, levels = @config[Clevels] || DefaultSeverityLevels, log = @config[Cdefault_log], cull = true)
-				Log.new({Cservice => facility, Clevels => levels, Clogfile => log, Ccull => cull})
+			def new_log(facility = Cdefault, levels = @config[Clevels] || DefaultSeverityLevels, log = @config[Cdefault_log], cull = true, roll = @config[Croll], roll_age = @config[Croll_age], roll_size = @config[Croll_size])
+				Log.new({Cservice => facility, Clevels => levels, Clogfile => log, Ccull => cull, Croll => roll, Croll_age => roll_age, Croll_size => roll_size})
 			end
 
 			def cleanup
@@ -87,8 +110,13 @@ module Swiftcore
 				end
 			end
 
+			def roll_logs
+				@logs.each do |service,l|
+				end
+			end
+
 			def update_now
-				@now = Time.now.strftime('%Y/%m/%d %H:%M:%S')
+				@now = Time.now.strftime(TimeFormat)
 			end
 
 			def config
@@ -102,12 +130,13 @@ module Swiftcore
 			def populate_logs
 				@config[Clogs].each do |log|
 					next unless log[Cservice]
+					roll = log[Croll] || log[Croll_age] || log[Croll_size] ? true : false
 					if Array === log[Cservice]
 						log[Cservice].each do |loglog|
-							@logs[loglog] = new_log(loglog,log[Clevels],logfile_destination(log[Clogfile]),log[Ccull])
+							@logs[loglog] = new_log(loglog,log[Clevels],logfile_destination(log[Clogfile]),log[Ccull],roll,log[Croll_age],log[Croll_size])
 						end
 					else
-						@logs[log[Cservice]] = new_log(log[Cservice],log[Clevels],logfile_destination(log[Clogfile]),log[Ccull])
+						@logs[log[Cservice]] = new_log(log[Cservice],log[Clevels],logfile_destination(log[Clogfile]),log[Ccull],roll,log[Croll_age],log[Croll_size])
 					end
 				end
 			end
@@ -153,6 +182,13 @@ module Swiftcore
 			end
 
 			def logfile_destination(logfile)
+				# We're reloading if it's already an IO.
+				if logfile.is_a?(IO)
+					return $stdout if logfile == $stdout
+					return $stderr if logfile == $stderr
+					return logfile.reopen(logfile.path, 'ab+')
+				end
+
 				if logfile =~ /^STDOUT$/i
 					$stdout
 				elsif logfile =~ /^STDERR$/i
@@ -183,19 +219,19 @@ module Swiftcore
 								last_count += 1
 								next
 							elsif last_count > 0
-								lf.puts "#{@now}|#{last_sv.join(C_bar)}|Last message repeated #{last_count} times"
+								lf.write_nonblock "#{@now}|#{last_sv.join(C_bar)}|Last message repeated #{last_count} times\n"
 								last_sv = last_m = nil
 								last_count = 0
 							end
-							lf.puts "#{@now}|#{m.join(C_bar)}"
+							lf.write_nonblock "#{@now}|#{m.join(C_bar)}\n"
 							last_m = m.last
 							last_sv = m[0..1]
 						else
-							lf.puts "#{@now}|#{m.join(C_bar)}"
+							lf.write_nonblock "#{@now}|#{m.join(C_bar)}\n"
 						end
 						@wcount += 1
 					end
-					lf.puts "#{@now}|#{last_sv.join(C_bar)}|Last message repeated #{last_count} times" if cull and last_count > 0
+					lf.write_nonblock "#{@now}|#{last_sv.join(C_bar)}|Last message repeated #{last_count} times\n" if cull and last_count > 0
 				end
 				@queue.each {|service,q| q.clear}
 			end
@@ -213,13 +249,16 @@ module Swiftcore
 	end
 
 	class Log
-		attr_reader :service, :levels, :logfile, :cull
+		attr_reader :service, :levels, :logfile, :cull, :roll, :roll_age, :roll_size
 
 		def initialize(spec)
 			@service = spec[Analogger::Cservice]
 			@levels = spec[Analogger::Clevels]
 			@logfile = spec[Analogger::Clogfile]
 			@cull = spec[Analogger::Ccull]
+			@roll = spec[Analogger::Croll]
+			@roll_inteval = spec[Analogger::Croll_age]
+			@roll_size = spec[Analogger::Croll_size]
 		end
 
 		def to_s
@@ -238,56 +277,15 @@ module Swiftcore
 			setup
 		end
 
-		def setup
-			@length = nil
-			@logchunk = ''
-			@authenticated = nil
-		end
-
-		def receive_data data
-			@logchunk << data
-			decompose = true
-			while decompose
-				unless @length
-					if @logchunk.length > 7
-						l = @logchunk[0..3].unpack(Ci).first
-						ck = @logchunk[4..7].unpack(Ci).first
-						if l == ck and l < MaxMessageLength
-							@length = l + 7
-						else
-							decompose = false
-							peer = get_peername
-							peer = peer ? ::Socket.unpack_sockaddr_in(peer)[1] : 'UNK'
-							if l == ck
-								LoggerClass.add_log([:default,:error,"Max Length Exceeded from #{peer} -- #{l}/#{MaxMessageLength}"])
-								close_connection
-							else
-								LoggerClass.add_log([:default,:error,"checksum failed from #{peer} -- #{l}/#{ck}"])
-								close_connection
-							end
-						end
-					end
-				end
-
-				if @length and @logchunk.length > @length
-					msg = @logchunk.slice!(0..@length).split(Rcolon,4)
-					unless @authenticated
-						if msg.last == LoggerClass.key
-							@authenticated = true
-						else
-							close_connection
-						end
-					else
-						msg[0] = nil
-						msg.shift
-						LoggerClass.add_log(msg)
-					end
-					@length = nil
-				else
-					decompose = false
-				end
-			end
-		end
-
 	end
 end
+
+case RUBY_VERSION
+when /^1.8/
+	require 'swiftcore/Analogger/receive_data_18.rb'
+when /^1.9/
+	require 'swiftcore/Analogger/receive_data_19.rb'
+else
+	raise "We're sorry, but Analogger is not supported for ruby versions prior to 1.8.x (and is untested below 1.8.5)."
+end
+

data/lib/swiftcore/Analogger/AnaloggerProtocol.rb

@@ -0,0 +1,78 @@
+module Swiftcore
+  class AnaloggerProtocol < EventMachine::Connection
+
+    MaxMessageLength = 8192
+    MaxLengthBytes = MaxMessageLength.to_s.length
+    Semaphore = "||"
+
+    def setup
+      @length = nil
+      @pos = 0
+      @logchunk = ''
+      @authenticated = nil
+    end
+
+    def send_data data
+      super data
+    end
+
+    def receive_data data
+      @logchunk << data
+      decompose = true
+      while decompose
+        unless @length
+          if @logchunk.length - @pos > 7
+            l = @logchunk[@pos + 0..@pos + 3].to_i
+            ck = @logchunk[@pos + 4..@pos + 7].to_i
+            if l == ck and l < MaxMessageLength
+              @length = l
+            else
+              decompose = false
+              peer = get_peername
+              peer = peer ? ::Socket.unpack_sockaddr_in(peer)[1] : 'UNK'
+              if l == ck
+                LoggerClass.add_log([:default, :error, "Max Length Exceeded from #{peer} -- #{l}/#{MaxMessageLength}"])
+                send_data "error: max length exceeded\n"
+                close_connection_after_writing
+              else
+                LoggerClass.add_log([:default, :error, "checksum failed from #{peer} -- #{l}/#{ck}"])
+                send_data "error: checksum failed\n"
+                close_connection_after_writing
+              end
+            end
+          end
+        end
+
+        if @length && @length < 8
+          decompose = false
+        end
+
+        if @length and @length > 0 and @logchunk.length - @pos >= @length
+          msg = nil
+          msg = @logchunk[@pos..@length + @pos - 1].split(Rcolon, 4)
+          @pos += @length
+          unless @authenticated
+            if msg.last == LoggerClass.key
+              @authenticated = true
+              send_data "accepted\n"
+            else
+              send_data "denied\n"
+              close_connection_after_writing
+            end
+          else
+            msg[0] = nil
+            msg.shift
+            LoggerClass.add_log(msg)
+          end
+          @length = nil
+        else
+          decompose = false
+        end
+      end
+      if @pos >= @logchunk.length
+        @logchunk.clear
+        @pos = 0
+      end
+    end
+  end
+end

data/lib/swiftcore/Analogger/Client.rb

@@ -0,0 +1,406 @@
+require 'tmpdir'
+require 'socket'
+
+include Socket::Constants
+
+module Swiftcore
+  class Analogger
+
+    # Swift::Analogger::Client is the client library for writing logging
+    # messages to the Swift Analogger asynchronous logging server.
+    #
+    # To use the Analogger client, instantiate an instance of the Client
+    # class.
+    #
+    #   logger = Swift::Analogger::Client.new(:myapplog,'127.0.0.1',12345)
+    #
+    # Four arguments are accepted when a new Client is created.  The first
+    # is the name of the logging facility that this Client will write to.
+    # The second is the hostname where the Analogger process is running,
+    # and the third is the port number that it is listening on for
+    # connections.
+    #
+    # The fourth argument is optional.  Analogger can require an
+    # authentication key before it will allow logging clients to use its
+    # facilities.  If the Analogger that one is connecting to requires
+    # an authentication key, it must be passed to the new() call as the
+    # fourth argument.  If the key is incorrect, the connection will be
+    # closed.
+    #
+    # If a Client connects to the Analogger using a facility that is
+    # undefined in the Analogger, the log messages will still be accepted,
+    # but they will be dumped to the default logging destination.
+    #
+    # Once connected, the Client is ready to deliver messages to the
+    # Analogger.  To send a messagine, the log() method is used:
+    #
+    #   logger.log(:debug,"The logging client is now connected.")
+    #
+    # The log() method takes two arguments.  The first is the severity of
+    # the message, and the second is the message itself.  The default
+    # Analogger severity levels are the same as in the standard Ruby
+    #
+    class Client
+
+      class FailedToAuthenticate < StandardError
+        def initialize(hots = "UNK", port = 6766)
+          super("Failed to authenticate to the Analogger server at #{destination}:#{port}")
+        end
+      end
+
+      Cauthentication = 'authentication'.freeze
+      Ci = 'i'.freeze
+
+      MaxMessageLength = 8192
+      MaxLengthBytes = MaxMessageLength.to_s.length
+      Semaphore = "||"
+      ConnectionFailureTimeout = 86400 * 2 # Log locally for a long time if Analogger server goes down.
+      MaxFailureCount = (2**(0.size * 8 - 2) - 1) # Max integer -- i.e. really big
+      PersistentQueueLimit = 10737412742 # Default to allowing around 10GB temporary local log storage
+      ReconnectThrottleInterval = 0.1
+
+      def log(severity, msg)
+        if @destination == :local
+          _local_log(@service, severity, msg)
+        else
+          _remote_log(@service, severity, msg)
+        end
+      rescue Exception
+        @authenticated = false
+        setup_local_logging
+        setup_reconnect_thread
+      end
+
+    #----- Various class accessors -- use these to set defaults
+
+      def self.connection_failure_timeout
+        @connection_failure_timeout ||= ConnectionFailureTimeout
+      end
+
+      def self.connection_failure_timeout=(val)
+        @connection_failure_timeout = val.to_i
+      end
+
+      def self.max_failure_count
+        @max_failure_count ||= MaxFailureCount
+      end
+
+      def self.max_failure_count=(val)
+        @max_failure_count = val.to_i
+      end
+
+      def self.persistent_queue_limit
+        @persistent_queue_limit ||= PersistentQueueLimit
+      end
+
+      def self.persistent_queue_limit=(val)
+        @persistent_queue_limit = val.to_i
+      end
+
+      def self.tmplog
+        @tmplog
+      end
+
+      def self.tmplog=(val)
+        @tmplog = val
+      end
+
+      def self.reconnect_throttle_interval
+        @reconnect_throttle_interval ||= ReconnectThrottleInterval
+      end
+
+      def self.reconnect_throttle_interval=(val)
+        @reconnect_throttle_interval = val.to_i
+      end
+
+    #-----
+
+      def initialize(service = 'default', host = '127.0.0.1' , port = 6766, key = nil)
+        @service = service.to_s
+        @key = key
+        @host = host
+        @port = port
+        klass = self.class
+        @connection_failure_timeout = klass.connection_failure_timeout
+        @max_failure_count = klass.max_failure_count
+        @persistent_queue_limit = klass.persistent_queue_limit
+        @authenticated = false
+        @total_count = 0
+        @logfile = nil
+        @swamp_drainer = nil
+
+        clear_failure
+
+        connect
+      end
+
+    #----- Various instance accessors
+
+      def total_count
+        @total_count
+      end
+
+      def connection_failure_timeout
+        @connection_failure_timeout
+      end
+
+      def connection_failure_timeout=(val)
+        @connection_failure_timeout = val.to_i
+      end
+
+      def max_failure_count
+        @max_failure_count
+      end
+
+      def max_failure_count=(val)
+        @max_failure_count = val.to_i
+      end
+
+      def ram_queue_limit
+        @ram_queue_limit
+      end
+
+      def ram_queue_limit=(val)
+        @ram_queue_limit = val.to_i
+      end
+
+      def persistent_queue_limit
+        @persistent_queue_limit
+      end
+
+      def persistent_queue_limit=(val)
+        @persistent_queue_limit = val.to_i
+      end
+
+      def tmplog_prefix
+        File.join(Dir.tmpdir, "analogger-SERVICE-PID.log")
+      end
+
+      def tmplog
+        @tmplog ||= tmplog_prefix.gsub(/SERVICE/, @service).gsub(/PID/,$$.to_s)
+      end
+
+      def tmplogs
+        Dir[tmplog_prefix.gsub(/SERVICE/, @service).gsub(/PID/,'*')].sort_by {|f| File.mtime(f)}
+      end
+
+      def tmplog=(val)
+        @tmplog = val
+      end
+
+      def reconnect_throttle_interval
+        @reconnect_throttle_interval ||= self.class.reconnect_throttle_interval
+      end
+
+      def reconnect_throttle_interval=(val)
+        @reconnect_throttle_interval = val.to_i
+      end
+
+    #----- The meat of the client
+
+      def connect
+        @socket = open_connection(@host, @port)
+        authenticate
+        raise FailedToAuthenticate(@host, @port) unless authenticated?
+        clear_failure
+
+        if there_is_a_swamp?
+          drain_the_swamp
+        else
+          setup_remote_logging
+        end
+
+      rescue Exception => e
+        register_failure
+        close_connection
+        setup_reconnect_thread unless @reconnection_thread && Thread.current == @reconnection_thread
+        setup_local_logging
+        raise e if fail_connect?
+      end
+
+      private
+
+      def setup_local_logging
+        unless @logfile && !@logfile.closed?
+          @logfile = File.open(tmplog,"a+")
+          @destination = :local
+        end
+      end
+
+      def setup_remote_logging
+        @destination = :remote
+      end
+
+      def setup_reconnect_thread
+        return if @reconnection_thread
+        @reconnection_thread = Thread.new do
+          while true
+            sleep reconnect_throttle_interval
+            connect rescue nil
+            break if @socket && !closed?
+          end
+          @reconnection_thread = nil
+        end
+      end
+
+      def _remote_log(service, severity, message)
+        @total_count += 1
+        len = MaxLengthBytes + MaxLengthBytes + service.length + severity.length + message.length + 3
+        ll = sprintf("%0#{MaxLengthBytes}i%0#{MaxLengthBytes}i", len, len)
+        @socket.write "#{ll}:#{service}:#{severity}:#{message}"
+      end
+
+      def _local_log(service, severity, message)
+        # Convert newlines to a different marker so that log messages can be stuffed onto a single file line.
+        @logfile.flock File::LOCK_EX
+        @logfile.puts "#{service}:#{severity}:#{message.gsub(/\n/,"\x00\x00")}"
+      ensure
+        @logfile.flock File::LOCK_UN
+      end
+
+      def open_connection(host, port)
+        socket = Socket.new(AF_INET,SOCK_STREAM,0)
+        sockaddr = Socket.pack_sockaddr_in(port,host)
+        socket.connect(sockaddr)
+        socket
+      end
+
+      def close_connection
+        @socket.close if @socket and !@socket.closed?
+      end
+
+      def register_failure
+        @failed_at ||= Time.now
+        @failure_count += 1
+      end
+
+      def fail_connect?
+        failed_too_many? || failed_too_long?
+      end
+
+      def failed?
+        !@failed_at.nil?
+      end
+
+      def failed_too_many?
+        @failure_count > @max_failure_count
+      end
+
+      def failed_too_long?
+        failed? && ( @failed_at + @connection_failure_timeout ) < Time.now
+      end
+
+      def clear_failure
+        @failed_at = nil
+        @failure_count = 0
+      end
+
+      def authenticate
+        begin
+          _remote_log(@service, Cauthentication, "#{@key}")
+          response = @socket.gets
+        rescue Exception
+          response = nil
+        end
+
+        if response && response =~ /accepted/
+          @authenticated = true
+        else
+          @authenticated = false
+        end
+      end
+
+      def there_is_a_swamp?
+        tmplogs.each do |logfile|
+          break true if FileTest.exist?(logfile) && File.size(logfile) > 0
+        end
+      end
+
+      def drain_the_swamp
+        unless @swamp_drainer
+          @swap_drainer = Thread.new { _drain_the_swamp }
+        end
+      end
+
+      def non_blocking_lock_on_file_handle(fh, &block)
+        fh.flock(File::LOCK_EX|File::LOCK_NB) ? yield : false
+      ensure
+        fh.flock File::LOCK_UN
+      end
+
+      def _drain_the_swamp
+        # As soon as we start emptying the local log file, ensure that no data
+        # gets missed because of IO buffering. Otherwise, during high rates of
+        # message sending, it is possible to get an EOF on file reading, and
+        # assume all data has been sent, when there are actually records which
+        # are buffered and just haven't been written yet.
+        @logfile && (@logfile.sync = true)
+
+        tmplogs.each do |logfile|
+          buffer = ''
+
+          FileTest.exist?(logfile) && File.open(logfile) do |fh|
+            non_blocking_lock_on_file_handle(fh) do # Only one process should read a given file.
+              fh.fdatasync rescue fh.fsync
+              logfile_not_empty = true
+              while logfile_not_empty
+                begin
+                  buffer << fh.read_nonblock(8192) unless closed?
+                rescue EOFError
+                  logfile_not_empty = false
+                end
+                records = buffer.scan(/^.*?\n/)
+                buffer = buffer[(records.inject(0) {|n, e| n += e.length})..-1] # truncate buffer
+                records.each_index do |n|
+                  record = records[n]
+                  next if record =~ /^\#/
+                  service, severity, msg = record.split(":", 3)
+                  msg = msg.chomp.gsub(/\x00\x00/, "\n")
+                  begin
+                    _remote_log(service, severity, msg)
+                  rescue
+                    # FAIL while draining the swamp. Just reset the buffer from wherever we are, and
+                    # keep trying, after a short sleep to allow for recovery.
+                    new_buffer = ''
+                    records[n..-1].each {|r| new_buffer << r}
+                    new_buffer << buffer
+                    buffer = new_buffer
+                    sleep 1
+                  end
+                end
+              end
+              File.unlink logfile
+            end
+            if tmplog == logfile
+              setup_remote_logging
+            end
+          end
+        end
+
+
+        @swamp_drainer = nil
+      rescue Exception => e
+        STDERR.puts "ERROR SENDING LOCALLY SAVED LOGS: #{e}\n#{e.backtrace.inspect}"
+      end
+
+      public
+
+      def authenticated?
+        @authenticated
+      end
+
+      def reconnect
+        connect(@host,@port)
+      end
+
+      def close
+        @socket.close
+      end
+
+      def closed?
+        @socket.closed?
+      end
+
+    end
+  end
+end