analogger 0.5.0

data/external/test_support.rb

@@ -0,0 +1,58 @@
+# A support module for the test suite.  This provides a win32 aware
+# mechanism for doing fork/exec operations.  It requires win32/process
+# to be installed, however.
+#
+module SwiftcoreTestSupport
+	@run_modes = []
+
+	def self.create_process(args)
+		@fork_ok = true unless @fork_ok == false
+		pid = nil
+		begin
+			raise NotImplementedError unless @fork_ok
+			unless pid = fork
+				Dir.chdir args[:dir]
+				exec(*args[:cmd])
+			end
+		rescue NotImplementedError
+			@fork_ok = false
+			begin
+				require 'rubygems'
+			rescue LoadError
+			end
+
+			begin
+				require 'win32/process'
+			rescue LoadError
+				raise "Please install win32-process to run all tests on a Win32 platform.  'gem install win32-process' or http://rubyforge.org/projects/win32utils"
+			end
+			cwd = Dir.pwd
+			Dir.chdir args[:dir]
+			pid = Process.create(:app_name => args[:cmd].join(' '))
+			Dir.chdir cwd
+		end
+		pid
+	end
+
+	def self.test_dir(dir)
+		File.dirname(File.expand_path(dir))
+	end
+
+	def self.cd_to_test_dir(dir)
+		Dir.chdir(File.dirname(File.expand_path(dir)))
+	end
+
+	def self.set_src_dir
+		$:.unshift File.expand_path(File.join(File.dirname(__FILE__),'../src'))
+	end
+
+	@announcements = {}
+	def self.announce(section,msg)
+		unless @announcements.has_key?(section)
+			puts "\n\n"
+			puts msg,"#{'=' * msg.length}\n\n"
+			@announcements[section] = true
+		end
+	end
+
+end

data/setup.rb

@@ -0,0 +1,26 @@
+#!ruby
+
+basedir = File.dirname(__FILE__)
+$:.push(basedir)
+
+require 'external/package'
+require 'rbconfig'
+begin
+	require 'rubygems'
+rescue LoadError
+end
+
+Dir.chdir(basedir)
+Package.setup("1.0") {
+	name "Swiftcore Analogger"
+
+	translate(:lib, 'src/' => '')
+	translate(:bin, 'bin/' => '')
+	lib(*Dir["src/swiftcore/**/*.rb"])
+	ri(*Dir["src/swiftcore/**/*.rb"])
+	bin "bin/analogger"
+
+	unit_test "test/TC_Analogger.rb"
+	
+	true
+}

data/src/swiftcore/Analogger.rb

@@ -0,0 +1,293 @@
+require 'socket'
+begin
+	load_attempted ||= false
+	require 'eventmachine'
+rescue LoadError => e
+	unless load_attempted
+		load_attempted = true
+		require 'rubygems'
+		retry
+	end
+	raise e
+end
+
+module Swiftcore
+	class Analogger
+		C_colon = ':'.freeze
+		C_bar = '|'.freeze
+		Ccull = 'cull'.freeze
+		Cdaemonize = 'daemonize'.freeze
+		Cdefault = 'default'.freeze
+		Cdefault_log = 'default_log'.freeze
+		Chost = 'host'.freeze
+		Cinterval = 'interval'.freeze
+		Ckey = 'key'.freeze
+		Clogfile = 'logfile'.freeze
+		Clogs = 'logs'.freeze
+		Cport = 'port'.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}
+
+		class NoPortProvided < Exception; def to_s; "The port to bind to was not provided."; end; end
+		class BadPort < Exception
+			def initialize(port)
+				@port = port
+			end
+
+		 	def to_s; "The port provided (#{@port}) is invalid."; end
+ 		end
+
+		class << self
+			def start(config,protocol = AnaloggerProtocol)
+				@config = config
+				daemonize if @config[Cdaemonize]
+				File.open(@config[Cpidfile],'w+') {|fh| fh.puts $$} if @config[Cpidfile]
+				@logs = Hash.new {|h,k| h[k] = new_log(k)}
+				@queue = Hash.new {|h,k| h[k] = []}
+				postprocess_config_load
+				check_config_settings
+				populate_logs
+				set_config_defaults
+				@rcount = 0
+				@wcount = 0
+				trap("INT") {cleanup;exit}
+				trap("TERM") {cleanup;exit}
+				trap("HUP") {cleanup;throw :hup}
+				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}
+				}
+			end
+
+			def daemonize
+				if (child_pid = fork)
+					puts "PID #{child_pid}" unless @config[Cpidfile]
+					exit!
+				end
+				Process.setsid
+
+			rescue Exception
+				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})
+			end
+
+			def cleanup
+				@logs.each do |service,l|
+					l.logfile.fsync if !l.logfile.closed? and l.logfile.fileno > 2
+					l.logfile.close unless l.logfile.closed? or l.logfile.fileno < 3
+				end
+			end
+
+			def update_now
+				@now = Time.now.strftime('%Y/%m/%d %H:%M:%S')
+			end
+
+			def config
+				@config
+			end
+
+			def config=(conf)
+				@config = conf
+			end
+
+			def populate_logs
+				@config[Clogs].each do |log|
+					next unless log[Cservice]
+					if Array === log[Cservice]
+						log[Cservice].each do |loglog|
+							@logs[loglog] = new_log(loglog,log[Clevels],logfile_destination(log[Clogfile]),log[Ccull])
+						end
+					else
+						@logs[log[Cservice]] = new_log(log[Cservice],log[Clevels],logfile_destination(log[Clogfile]),log[Ccull])
+					end
+				end
+			end
+
+			def postprocess_config_load
+				@config[Clogs] ||= []
+				if @config[Clevels]
+					@config[Clevels] = normalize_levels(@config[Clevels])
+				end
+
+				@config[Clogs].each do |log|
+					log[Clevels] = normalize_levels(log[Clevels])
+				end
+			end
+
+			def normalize_levels(levels)
+				if String === levels and levels =~ /,/
+					levels.split(/,/).inject({}) {|h,k| h[k.to_s] = true; h}
+				elsif Array === levels
+					levels.inject({}) {|h,k| h[k.to_s] = true; h}
+				elsif levels.nil?
+					DefaultSeverityLevels
+				elsif !(Hash === levels)
+					[levels.to_s => true]
+				else
+					levels
+				end
+			end
+
+			def check_config_settings
+				raise NoPortProvided unless @config[Cport]
+				raise BadPort.new(@config[Cport]) unless @config[Cport].to_i > 0
+			end
+
+			def set_config_defaults
+				@config[Chost] ||= '127.0.0.1'
+				@config[Cinterval] ||= 1
+				@config[Csyncinterval] ||= 60
+				@config[Csyncinterval] = nil if @config[Csyncinterval] == 0
+				@config[Cdefault_log] = @config[Cdefault_log].nil? || @config[Cdefault_log] == '-' ? 'STDOUT' : @config[Cdefault_log]
+				@config[Cdefault_log] = logfile_destination(@config[Cdefault_log])
+				@logs['default'] = new_log
+			end
+
+			def logfile_destination(logfile)
+				if logfile =~ /^STDOUT$/i
+					$stdout
+				elsif logfile =~ /^STDERR$/i
+					$stderr
+				else
+					File.open(logfile,'ab+')
+				end
+			end
+
+			def add_log(log)
+				@queue[log.first] << log
+				@rcount += 1
+			end
+
+			def write_queue
+				@queue.each do |service,q|
+					last_sv = nil
+					last_m = nil
+					last_count = 0
+					next unless log = @logs[service]
+					lf = log.logfile
+					cull = log.cull
+					levels = log.levels
+					q.each do |m|
+						next unless levels.has_key?(m[1])
+						if cull
+							if m.last == last_m and m[0..1] == last_sv
+								last_count += 1
+								next
+							elsif last_count > 0
+								lf.puts "#{@now}|#{last_sv.join(C_bar)}|Last message repeated #{last_count} times"
+								last_sv = last_m = nil
+								last_count = 0
+							end
+							lf.puts "#{@now}|#{m.join(C_bar)}"
+							last_m = m.last
+							last_sv = m[0..1]
+						else
+							lf.puts "#{@now}|#{m.join(C_bar)}"
+						end
+						@wcount += 1
+					end
+					lf.puts "#{@now}|#{last_sv.join(C_bar)}|Last message repeated #{last_count} times" if cull and last_count > 0
+				end
+				@queue.each {|service,q| q.clear}
+			end
+
+			def flush_queue
+				@logs.each_value {|l| l.logfile.fsync if l.logfile.fileno > 2}
+			end
+
+			def key
+				@config[Ckey].to_s
+			end
+
+		end
+
+	end
+
+	class Log
+		attr_reader :service, :levels, :logfile, :cull
+
+		def initialize(spec)
+			@service = spec[Analogger::Cservice]
+			@levels = spec[Analogger::Clevels]
+			@logfile = spec[Analogger::Clogfile]
+			@cull = spec[Analogger::Ccull]
+		end
+
+		def to_s
+			"service: #{@service}\nlevels: #{@levels.inspect}\nlogfile: #{@logfile}\ncull: #{@cull}\n"
+		end
+	end
+
+	class AnaloggerProtocol < EventMachine::Connection
+		Ci = 'i'.freeze
+		Rcolon = /:/
+		MaxMessageLength = 8192
+
+		LoggerClass = Analogger
+
+		def post_init
+			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

data/src/swiftcore/Analogger/Client.rb

@@ -0,0 +1,103 @@
+require 'socket'
+include Socket::Constants
+
+module Swiftcore
+	module 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
+			Cauthentication = 'authentication'.freeze
+			Ci = 'i'.freeze
+
+			def initialize(service = 'default', host = '127.0.0.1' , port = 6766, key = nil)
+				@service = service.to_s
+				@key = key
+				@host = host
+				@port = port
+				connect(host,port)
+			end
+
+			def connect(host,port)
+				tries ||= 0
+				@socket = Socket.new(AF_INET,SOCK_STREAM,0)
+				sockaddr = Socket.pack_sockaddr_in(port,host)
+				@socket.connect(sockaddr)
+				log(Cauthentication,"#{@key}")
+			rescue Exception => e
+				if tries < 3
+					tries += 1
+					@socket.close unless @socket.closed?
+					@socket = nil
+					select(nil,nil,nil,tries * 0.2) if tries > 0
+					retry
+				else
+					raise e
+				end
+			end
+
+			def reconnect
+				connect(@host,@port)
+			end
+
+			def log(severity,msg)
+				tries ||= 0
+				fullmsg = ":#{@service}:#{severity}:#{msg}"
+				len = [fullmsg.length].pack(Ci)
+				@socket.write "#{len}#{len}#{fullmsg}"
+			rescue Exception => e
+				if tries < 3
+					tries += 1
+					@socket.close unless @socket.closed?
+					@socket = nil
+					select(nil,nil,nil,tries) if tries > 0
+					reconnect
+					retry
+				else
+					raise e
+				end
+			end
+
+			def close
+				@socket.close
+			end
+
+			def closed?
+				@socket.closed?
+			end
+
+		end
+	end
+end