butler 1.8.0

data/lib/log/converter.rb

@@ -0,0 +1,23 @@
+#--
+# Copyright 2007 by Stefan Rusterholz.
+# All rights reserved.
+# See LICENSE.txt for permissions.
+#++
+
+
+
+module Log
+	module Converter
+		def default_type
+			:info
+		end
+
+		def convert(obj)
+			case obj
+				when Entry:     obj
+				when Exception:	Entry.new(obj.message.chomp, :error, obj.backtrace)
+				else            Entry.new(obj.to_str.chomp, default_type)
+			end
+		end
+	end
+end

data/lib/log/entry.rb

@@ -0,0 +1,152 @@
+#--
+# Copyright 2007 by Stefan Rusterholz.
+# All rights reserved.
+# See LICENSE.txt for permissions.
+#++
+
+
+
+require 'enumerator'
+require 'log'
+
+
+
+module Log
+	# currently unused
+	Printable  = "%d#{RecordSeparator}%s#{RecordSeparator}%s#{RecordSeparator}%s"
+	# currently *only* used by Entry#serialize, but not by Entry::deserialize
+	Serialized =
+		"%d#{RecordSeparator}" \
+		"%s#{RecordSeparator}" \
+		"%s#{RecordSeparator}" \
+		"%s#{RecordSeparator}" \
+		"%s"
+
+	class Entry
+		class <<self
+			attr_accessor :time_format
+			
+			def deserialize(line)
+				time, severity, text, flagstr, data = line.chomp(RecordTerminator).split(RecordSeparator)
+				flags = {}
+				flagstr.split(UnitSeparator).each_cons(2) { |key, value|
+					flagstr[key] = value
+				}
+				severity = Integer(severity) rescue severity
+				new(text, InvSeverity[severity], Marshal.load(Log.unescape(data)), Time.at(time.to_i), flags)
+			end
+
+			def formatter_for(entity, &formatter)
+				@formatter[entity] = formatter
+			end
+			
+			def format(entity, value, *args)
+				@formatter[entity].call(value, *args)
+			end
+
+			def format_time(entry, time, format=nil)
+				entry.time.strftime(format || @time_format)
+			end
+
+			def format_severity(entry)
+				entry.severity.to_s
+			end
+			
+			def format_flags(entry, flags)
+				entry.flags.map{ |k,v| "#{k}: #{v}"}.join(", ")
+			end
+			
+			def format_text(entry)
+				entry.text.chomp.gsub(/[\r\n]+/, '; ').gsub(/[\x00-\x1f\x7f]/, '.')
+			end
+		end
+
+		Severity = Hash.new{|h,k|k}.merge({
+			:debug => 1,
+			:info  => 2,
+			:warn  => 4,
+			:error => 8,
+			:fail  => 16,
+		})
+		InvSeverity = Severity.invert
+		@formatter = {
+			"time"     => method(:format_time),
+			"severity" => method(:format_severity),
+			"flags"    => method(:format_flags),
+			"text"     => method(:format_text), #Log.method(:escape),
+		}
+		@time_format = "%FT%T"
+		
+		attr_reader :time
+		attr_reader :severity
+		attr_reader :text
+		attr_reader :flags
+		attr_reader :data
+		def initialize(text, severity=:info, data=nil, *flags)
+			@time     = flags.first.kind_of?(Time) ? flags.shift : Time.now
+			@severity = severity
+			@text     = text
+			@data     = data
+			@flags    = flags.last.kind_of?(Hash) ? flags.pop : {}
+			@flags.each_key { |k,v| @flags[k.to_s] = @flags.delete(k) }
+			flags.each { |flag| @flags[flag.to_s] = true }
+		end
+		
+		def [](key)
+			@flags[key]
+		end
+		
+		def debug?
+			@severity == Severity[:debug]
+		end
+
+		def info?
+			@severity == Severity[:info]
+		end
+
+		def warn?
+			@severity == Severity[:warn]
+		end
+
+		def error?
+			@severity == Severity[:error]
+		end
+
+		def fail?
+			@severity == Severity[:fail]
+		end
+
+		def serialize
+			Serialized %  [
+				@time,
+				Severity[@severity],
+				Log.escape(@text),
+				@flags.map.join(UnitSeparator),
+				Log.escape(Marshal.dump(@data))
+			]
+		end
+	
+		def to_s(format=nil)
+			format ||= "%{time:%FT%T} [%{severity}]: %{text}"
+			format.gsub(/%(%|\{[^}]+\})/) { |match|
+				if match == "%%" then
+					"%"
+				else
+					entity, *args = match[2..-2].split(/:/)
+					Entry.format(entity, self, *args)
+				end
+			}
+		end
+		
+		def inspect
+			"#<%s %s %s %s flags=%s data=%s>" %  [
+				self.class,
+				@time.strftime("%FT%T"),
+				@severity,
+				@text.inspect,
+				@flags.inspect,
+				@data.inspect
+			]
+		end
+	end
+end

data/lib/log/fakeio.rb

@@ -0,0 +1,55 @@
+#--
+# Copyright 2007 by Stefan Rusterholz.
+# All rights reserved.
+# See LICENSE.txt for permissions.
+#++
+
+
+
+module Log
+	# == Description
+	# Fakes most IO methods and forwards the converted data to #process
+	#
+	# == Requisites
+	# * @buffer initialized to ""
+	# * #process method present (this should write to the storage)
+	# * #convert method present (see Log::Converter)
+	#
+	# == Notes
+	# Following methods might be useful to be implemented:
+	#   binmode, fcntl, fileno, flush, fsync, isatty, lineno, lineno=, pid, pos,
+	#   pos=, , scanf, seek, soak_up_spaces, stat, sync, sync=, sysread, tell, to_i,
+	#   to_io, tty?
+	#
+	# Following write methods are NOT implemented:
+	#   puts, syswrite, write_nonblock
+	#
+	# All read methods must be implemented by the including class
+	#     
+	module FakeIO
+		def process_buffer
+			while line = @buffer.slice!(/.*?\n/)
+				process(convert(line))
+			end
+		end
+
+		def <<(obj)
+			process(convert(obj))
+		end
+
+		def puts(*objs)
+			objs.each { |obj| process(convert(obj)) }
+		end
+
+		def write(*objs)
+			@buffer << objs.join("")
+			process_buffer
+		end
+		alias print write
+
+		def printf(*args)
+			@buffer << sprintf(*args)
+			process_buffer
+		end
+	end
+end

data/lib/log/file.rb

@@ -0,0 +1,54 @@
+#--
+# Copyright 2007 by Stefan Rusterholz.
+# All rights reserved.
+# See LICENSE.txt for permissions.
+#++
+
+
+
+require 'log/converter'
+require 'log/fakeio'
+require 'log/methods'
+
+
+
+module Log
+	# Log.file is equivalent to Log::File.new
+	def self.file(*args)
+		Log::File.new(*args)
+	end
+
+	class File
+		include Converter
+		include FakeIO
+		include Methods
+
+		def initialize(out)
+			@out          = nil
+			@default_type = :error
+			@buffer       = ""
+			reopen(out)
+		end
+		
+		def process(obj)
+			@out.puts(obj.serialize)
+			@out.flush
+		end
+		
+		def reopen(out)
+			close
+			@out = out.respond_to?(:to_str) ? ::File.open(out, "a") : out
+			raise TypeError, "out #{@out} does not respond to 'puts'." unless @out.respond_to?(:puts)
+			self
+		end
+
+		def close
+			@out.close if @out.respond_to?(:close)
+			self
+		end
+		
+		def closed?
+			@out.respond_to?(:close) ? @out.closed? : true
+		end
+	end
+end

data/lib/log/filereader.rb

@@ -0,0 +1,81 @@
+module Log
+	class FileReader
+		include Enumerable
+		class Filter
+			module Grep;         def =~(entry); entry.text =~ @arg1;             end; end
+			module NoGrep;       def =~(entry); entry.text !~ @arg1;             end; end
+			module Find;         def =~(entry); entry.text.include?(@arg1);      end; end
+			module NoFind;       def =~(entry); !entry.text.include?(@arg1);     end; end
+			module StartDate;    def =~(entry); entry.time > @arg1;              end; end
+			module EndDate;      def =~(entry); entry.time < @arg1;              end; end
+			module OneOfLevels;  def =~(entry); @arg1.include?(entry.severity);  end; end
+			module NoneOfLevels; def =~(entry); !@arg1.include?(entry.severity); end; end
+
+			Types = {
+				:grep           => Grep,
+				:no_grep        => NoGrep,
+				:find           => Find,
+				:no_find        => NoFind,
+				:start_date     => StartDate,
+				:end_date       => EndDate,
+				:one_of_levels  => OneOfLevels,
+				:none_of_levels => NoneOfLevels,
+			}
+
+			def initialize(type, *args)
+				extend Types[type]
+				@arg1 = args.first
+				@args = args
+			end
+		end
+
+		def initialize(file)
+			@file    = ::File.open(file, "r")
+			@pos     = 0
+			@cache   = {}
+			@filters = []
+		end
+		
+		def add_filter(type, *args)
+			@filters << Filter.new(type, *args)
+		end
+		
+		def matches(entry)
+			@filters.all? { |filter| filter =~ entry }
+		end		
+		
+		def head(n)
+			i = 0
+			while line = @file.gets and i < n
+				entry = Log::Entry.deserialize(line)
+				if matches(entry) then
+					yield(entry)
+					i+=1
+				end
+			end
+			entries
+		end
+
+		def tail(n, &block)
+			entries = []
+			while line = @file.gets and entries.length < n
+				entry = Log::Entry.deserialize(line)
+				entries.push entry if matches(entry)
+			end
+			while line = @file.gets
+				entry = Log::Entry.deserialize(line)
+				entries.push entry if matches(entry)
+				entries.shift
+			end
+			entries.compact
+			entries.each(&block)
+		end
+		
+		def each
+			while line = @file.gets
+				entry = Log::Entry.deserialize(line)
+				yield(entry) if matches(entry)
+			end
+		end
+	end
+end

data/lib/log/forward.rb

@@ -0,0 +1,49 @@
+#--
+# Copyright 2007 by Stefan Rusterholz.
+# All rights reserved.
+# See LICENSE.txt for permissions.
+#++
+
+
+
+require 'log/fakeio'
+require 'log/converter'
+
+
+
+module Log
+	# Log.forward is equivalent to Log::Forward.new
+	def self.forward(*args)
+		Forward.new(*args)
+	end
+
+	# Forward an IO to an object (object must respond to #puts)
+	# Will convert all puts/prints etc. to Log::Entry's using
+	# Log::Converter#convert
+	# Example:
+	#   $stderr = Log.forward(your_logfile)
+	class Forward
+		include FakeIO
+		include Converter
+
+		def initialize(to, type=:info)
+			raise ArgumentError, "Target must respond to 'puts'" unless to.respond_to?(:puts)
+			@to           = to
+			@default_type = type
+			@buffer       = ""
+		end
+		
+		def process(obj)
+			@to.puts(obj)
+		end
+		
+		def inspect
+			"#<%s:%08x %s %s>" %  [
+				self.class,
+				object_id,
+				@default_type,
+				@to.inspect
+			]
+		end
+	end
+end

data/lib/log/methods.rb

@@ -0,0 +1,39 @@
+#--
+# Copyright 2007 by Stefan Rusterholz.
+# All rights reserved.
+# See LICENSE.txt for permissions.
+#++
+
+
+
+module Log
+	# Provides convenience mappings to #process
+	# Map debug, info, warn, error, fail to log, log itself uses process with
+	# Entry.new
+	# See Log::File for an example.
+	module Methods
+		def log(*args)
+			process(Entry.new(*args))
+		end
+		
+		def debug(text, *args)
+			log(text, :debug, *args)
+		end
+
+		def info(text, *args)
+			log(text, :info, *args)
+		end
+
+		def warn(text, *args)
+			log(text, :warn, *args)
+		end
+
+		def error(text, *args)
+			log(text, :error, *args)
+		end
+
+		def fail(text, *args)
+			log(text, :fail, *args)
+		end
+	end
+end