globalog 0.1.1

data/lib/globalog.rb

@@ -0,0 +1,110 @@
+# This gem aims to provide a global cascading logging system, command line arguments aware,
+# to centralize the settings of your individual loggers.  
+# 
+# It is thought to be compatible with other gems using OptionParser to collect command line arguments, by hijacking the ARGV at require time before others grabs it.  (So, it must be required before say, 'Test/Unit' to hijack the ARGV).
+# 
+# Each individual logger can follow the setting's cascade, or not.  If it does, the command line arguments or the first globalog to setup its parameters have precedence over the local settings.  And in case no other globalog is setup is present, the local parameters are used for logging.
+# 
+# It is essentially compatible with existing Logger, because it uses logger as it base lib.  So all logging is done the same way, with all of logger instance methods also working on globalog instances.  You can then transition code logged with logger easily, by either replacing the Logger initialisation in your code by a GlobaLog initialisation, or by leaving logger where it is and only deriving its output and level settings from globalog class methods of the same names, still allowing you to tap into globalog cascading settings.
+# 
+# The logging in Globalog is done with Logger so please refer to its documentation for the logging methodologies: http://www.ruby-doc.org/stdlib/libdoc/logger/rdoc/
+# 
+# ///////////////////////////////////////////////////////////////////////////////////////
+# Example:
+# 
+#   # script1.rb
+#   require 'globalog'
+#   $log = GlobaLog.logger(STDERR,:warn)
+#   
+#   module Script1
+#     def example
+#       $log.warn("Example") {"Printing Warning!!"}
+#       $log.info("Example") {"Printing Info!!"}
+#       $log.debug("Example") {"Printing Debug!!"}
+#     end
+#   end
+#   
+# calling the example method will result in:
+# 
+#   Script1.example   # => Printing Warning!!
+#   
+# But if you require script1, inside an other script, setting different GlobaLog init parameters, they will have precedence and cascade down as in the example below.
+# 
+#   # script2.rb
+#   require 'globalog'
+#   require 'script1'
+#   
+#   $log = GlobaLog.logger(STDERR,:info)
+#   Script1.example
+#   
+# running script2 will output:
+#   
+#   > ruby script2.rb
+#   => Printing Warning!!
+#   => Printing Info!!
+#   
+# And you can also run script2 with arguments to get different log level or output:
+# 
+#   > ruby script2.rb -L debug
+#   => Printing Warning!!
+#   => Printing Info!!
+#   => Printing Debug!!
+#   
+# So this allow you to set a default Logger setting in your libraries, override them with an other default setting in client scripts and still get the flexibility to override both defaults at runtime by providing command line arguments.  Ideal for testing purposes where you want a default log level for test overriding the Local log level of your tested libraries, while allowing you to choose the test log level at runtime. 
+#
+#  
+# Author:: lp (mailto:lp@spiralix.org)
+# Copyright:: 2009 Louis-Philippe Perron - Released under the terms of the MIT license
+# 
+# :title:GlobaLog
+
+require 'logger'
+class GlobaLog < Logger
+	require 'globalog_args'
+	require 'globalog_hijack'
+	
+	# The +GlobaLog.logger+ acts as a constructor method for the logger.
+	# === Parameters
+	# * _def_out_ = the output io or logfile path
+	# * _def_level_ = the log level, as a symbol (i.e. :warn, :info, etc)
+	# * _master_ = (optional) the logger presence in the cascading settings chain
+	# _master_ can be any of the following:
+	# * _true_ = Impose its settings on the loggers down the chain
+	# * _false_ = Use the chain settings if present (default)
+	# * _nil_ = Is out of the chain
+	# === Example
+	# 	@log = GlobaLog.logger('logfile.txt',:error,true)
+	
+	def GlobaLog.logger(def_out,def_level,master=false)
+		Args.are({:log_output => def_out, :log_level => def_level},master)	
+		if master.nil?
+			log = self.new(def_out)
+			log.level = Args.sym_to_level(def_level)
+		else
+			log = self.new(Args::log_output)
+			log.level = Args::log_level
+		end
+		return log
+	end
+	
+	# The +GlobaLog::output+ method return the current log output.
+	# Can be used to chain existing Logger instances to GlobaLog cascade, 
+	# when you don't want to replace them with GlobaLog instances.
+	# (and you can only replace the constructor, the logging will still work)
+	# === Example
+	# 	$logger = Logger.new(GlobaLog::output)
+	def GlobaLog::output
+		Args::log_output
+	end
+	
+	# The +Globalog::level+ method returns the current log level.
+	# Can be used to chain existing Logger instances to GlobaLog cascade, 
+	# when you don't want to replace them with GlobaLog instances.
+	# (and you can only replace the constructor, the logging will still work)
+	# === Example
+	# 	$logger.level = GlobaLog::level
+	def GlobaLog::level
+		Args::log_level
+	end
+	
+end

data/lib/globalog_args.rb

@@ -0,0 +1,50 @@
+class GlobaLog
+	# The Args module manages the GlobaLog arguments in the background.
+	# Author:: lp (mailto:lp@spiralix.org)
+	# Copyright:: 2009 Louis-Philippe Perron - Released under the terms of the MIT license
+	# 
+	# :title:GlobaLog/Args
+	module Args
+		
+		def Args.are(args,override=false)
+			$logger_args ||= Hash.new
+			if override == true
+				$logger_args[:log_level] = args[:log_level].to_sym unless args[:log_level].nil?
+				$logger_args[:log_output] = args[:log_output] unless args[:log_output].nil?
+			else
+				$logger_args[:log_level] ||= args[:log_level].to_sym unless args[:log_level].nil?
+				$logger_args[:log_output] ||= args[:log_output] unless args[:log_output].nil?
+			end
+		end
+		
+		def Args::log_output
+			$logger_args[:log_output]
+		end
+
+		def Args::log_level
+			if $logger_args[:log_level].is_a?(Symbol)
+				$logger_args[:log_level] = self.sym_to_level($logger_args[:log_level])
+			end
+			$logger_args[:log_level]
+		end
+		
+		def Args.sym_to_level(sym)
+			case sym
+			when :debug
+				return Logger::DEBUG
+			when :info
+				return Logger::INFO
+			when :warn
+				return Logger::WARN
+			when :error
+				return Logger::ERROR
+			when :fatal
+				return Logger::FATAL
+			else
+				return Logger::UNKNOWN
+			end
+		end
+		
+	end
+	
+end

data/lib/globalog_hijack.rb

@@ -0,0 +1,51 @@
+class GlobaLog
+	# The Hijack class manages the acquisition of command line arguments,
+	# playing nicely with other command line aware libs.
+	# Author:: lp (mailto:lp@spiralix.org)
+	# Copyright:: 2009 Louis-Philippe Perron - Released under the terms of the MIT license
+	# 
+	# :title:GlobaLog/Hijack
+	class Hijack < Hash
+		require 'optparse'
+		
+		def initialize
+			super()
+			self[:log_level] = nil
+			self[:log_output] = nil
+			opts = OptionParser.new do |opts|
+				opts.on('-L','--log-level [STRING]','sets the Test Log Level') do |string|
+					self[:log_level] = string.to_sym
+				end
+				opts.on('-O','--log-output [I/O]','sets the Test Log output') do |io|
+					self[:log_output] = io
+				end
+			end
+			opts.parse!($keep_argv)
+		end
+
+		def self.keep_wanted_argv
+			args = Array.new(ARGV); ARGV.clear; keep = []
+			wanted = ['-L', '--log-level', '-O', '--log-output']
+			catch :finished do
+				loop do
+					throw :finished if args.empty?
+					catch :found do
+						wanted.each do |arg|
+							if args[0] == arg
+								2.times { keep << args.shift }
+								throw :found
+							end
+						end
+						ARGV << args.shift
+					end
+				end
+			end
+			$keep_argv ||= keep
+		end
+
+		self.keep_wanted_argv
+		Args.are(self.new)
+
+	end
+	
+end

data/test/external_helper.rb

@@ -0,0 +1,25 @@
+module LogMessage
+	
+	def log_all_level(identifier)
+		@log.debug('test') {"#{identifier} -- debug"}
+		@log.info('test') {"#{identifier} -- info"}
+		@log.warn('test') {"#{identifier} -- warn"}
+		@log.error('test') {"#{identifier} -- error"}
+		@log.fatal('test') {"#{identifier} -- fatal"}
+		@log.unknown('test') {"#{identifier} -- unknown"}
+	end
+	
+end
+
+class External
+	include LogMessage
+	
+	def initialize
+		@log = GlobaLog.logger(STDERR,:warn)
+	end
+	
+	def log
+		log_all_level('external')
+	end
+	
+end

data/test/tc_globalog_main.rb

@@ -0,0 +1,126 @@
+$:.unshift File.join(File.dirname(__FILE__), "..", "lib")
+require 'globalog'
+require 'test/unit'
+
+require 'test/external_helper'
+
+class TestGlobaLogMain < Test::Unit::TestCase
+	include LogMessage
+	$test_file = 'test_log'
+	
+	def setup
+		File.new($test_file,'w').close
+	end
+	
+	def test_globalog
+		output = STDERR
+		level = :error
+		@log = GlobaLog.logger(output,level,true)
+		assert_equal(output,GlobaLog::output)
+		assert_equal(3,GlobaLog::level)
+	end
+	
+	def test_globalog_debug
+		prepare_test(:debug)
+		check_test(:debug)	
+	end
+	
+	def test_globalog_info
+		prepare_test(:info)
+		check_test(:info)	
+	end
+	
+	def test_globalog_warn
+		prepare_test(:warn)
+		check_test(:warn)	
+	end
+	
+	def test_globalog_error
+		prepare_test(:error)
+		check_test(:error)	
+	end
+	
+	def test_globalog_fatal
+		prepare_test(:fatal)
+		check_test(:fatal)	
+	end
+	
+	def test_globalog_unknown
+		prepare_test(:unknown)
+		check_test(:unknown)	
+	end
+	
+	def teardown
+		@log.close
+		File.delete($test_file)
+	end
+	
+	private
+	
+	def prepare_test(level)
+		@log = GlobaLog.logger($test_file,level,true)
+		log_all_level('base test')
+		pid1 = fork {log_all_level('fork 1'); exit}
+		pid2 = fork {log_all_level('fork 2'); exit}
+		Process.waitpid(pid2,0)
+		External.new().log
+	end
+	
+	def check_test(level)
+		f = File.open($test_file,'r'); content = f.read; f.close
+		check_players(content)
+		check_level(level,content)
+	end
+	
+	def check_players(content)
+		assert_match(/base/,content)
+		assert_match(/fork 1/,content)
+		assert_match(/fork 2/,content)
+		assert_match(/external/,content)
+	end
+	
+	def check_level(level,content)
+		level_match = match_assertions(content)
+		level_no_match = no_match_assertions(content)
+		case level
+		when :debug
+			0.upto(5) { |num| level_match[num].call }
+		when :info
+			0.upto(4) { |num| level_match[num].call }
+			5.downto(5) { |num| level_no_match[num].call }
+		when :warn
+			0.upto(3) { |num| level_match[num].call }
+			5.downto(4) { |num| level_no_match[num].call }
+		when :error
+			0.upto(2) { |num| level_match[num].call }
+			5.downto(3) { |num| level_no_match[num].call }
+		when :fatal
+			0.upto(1) { |num| level_match[num].call }
+			5.downto(2) { |num| level_no_match[num].call }
+		when :unknown
+			0.upto(0) { |num| level_match[num].call }
+			5.downto(1) { |num| level_no_match[num].call }
+		end
+	end
+	
+	def match_assertions(content)
+		[ lambda { assert_match(/unknown/,content) },
+			lambda { assert_match(/fatal/,content) },
+			lambda { assert_match(/error/,content) },
+			lambda { assert_match(/warn/,content) },
+			lambda { assert_match(/info/,content) },
+			lambda { assert_match(/debug/,content) } ]
+	end
+	
+	def no_match_assertions(content)
+		[ lambda { assert_no_match(/unknown/,content) },
+			lambda { assert_no_match(/fatal/,content) },
+			lambda { assert_no_match(/error/,content) },
+			lambda { assert_no_match(/warn/,content) },
+			lambda { assert_no_match(/info/,content) },
+			lambda { assert_no_match(/debug/,content) } ]
+	end
+	
+	
+	
+end

metadata

@@ -0,0 +1,57 @@
+--- !ruby/object:Gem::Specification 
+name: globalog
+version: !ruby/object:Gem::Version 
+  version: 0.1.1
+platform: ruby
+authors: 
+- Louis-Philippe Perron
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2009-02-12 00:00:00 -05:00
+default_executable: 
+dependencies: []
+
+description: 
+email: lp@spiralix.org
+executables: []
+
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- lib/globalog.rb
+- lib/globalog_args.rb
+- lib/globalog_hijack.rb
+- test/external_helper.rb
+- test/tc_globalog_main.rb
+has_rdoc: true
+homepage: http://globalog.rubyforge.org/
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+requirements: []
+
+rubyforge_project: GlobaLog
+rubygems_version: 1.2.0
+signing_key: 
+specification_version: 2
+summary: Cascading Global Log
+test_files: 
+- test/tc_globalog_main.rb