ptomato-ramaze 2009.02

data/lib/ramaze/log/analogger.rb

@@ -0,0 +1,40 @@
+#          Copyright (c) 2008 Michael Fellinger m.fellinger@gmail.com
+# All files in this distribution are subject to the terms of the Ruby license.
+
+require 'swiftcore/Analogger/Client'
+
+module Ramaze
+  module Logger
+
+    # Informer for the Swiftcore Analogger logging system.
+    #
+    # You can find it at http://analogger.swiftcore.org and install with
+    # gem install analogger
+
+    class Analogger < ::Swiftcore::Analogger::Client
+      include Logging
+
+      # identifier for your application
+      trait :name => 'walrus'
+
+      # Host analogger runs on
+      trait :host => '127.0.0.1'
+
+      # Port analogger runs on
+      trait :port => 6766
+
+      # Create a new instance, parameters default to the traits.
+
+      def initialize(name = class_trait[:name], host = class_trait[:host], port = class_trait[:port])
+        super
+      end
+
+      # integration to Logging
+
+      def log(tag, *args)
+        log(tag, args.join("\n"))
+      end
+    end
+
+  end
+end

data/lib/ramaze/log/growl.rb

@@ -0,0 +1,38 @@
+#          Copyright (c) 2008 Michael Fellinger m.fellinger@gmail.com
+# All files in this distribution are subject to the terms of the Ruby license.
+
+require 'ruby-growl'
+
+module Ramaze
+  module Logger
+
+    # Informer for the growl notification system on OSX.
+
+    class Growl < ::Growl
+
+      trait :defaults => {
+        :name => 'walrus',
+        :host => 'localhost',
+        :password => 'walrus',
+        :all_notifies => %w[error warn debug info dev],
+        :default_notifies => %w[error warn info]
+      }
+
+      # Takes the options from the default trait for merging.
+
+      def initialize(options = {})
+        options = class_trait[:defaults].merge(options).values_at(:host, :name, :all_notifies, :default_notifies, :password)
+        super(*options)
+      end
+
+      # integration to Logging
+
+      def log(tag, *args)
+        notify(tag.to_s, Time.now.strftime("%X"), args.join("\n")[0..100])
+      rescue Errno::EMSGSIZE
+        # Send size was to big (not really), ignore
+      end
+    end
+
+  end
+end

data/lib/ramaze/log/hub.rb

@@ -0,0 +1,41 @@
+#          Copyright (c) 2008 Michael Fellinger m.fellinger@gmail.com
+# All files in this distribution are subject to the terms of the Ruby license.
+
+module Ramaze
+  module Logger
+
+    # Bundles different informer instances and sends incoming messages to each.
+    # This is the default with Informer as only member.
+
+    class LogHub
+      include Logging
+
+      attr_accessor :loggers
+      attr_accessor :ignored_tags
+
+      # Takes a list of instances or classes (which will be initialized) and that
+      # are added to @loggers. All messages are then sent to each member.
+
+      def initialize(*loggers)
+        @loggers = loggers
+        @ignored_tags = Set.new
+        @loggers.map! do |logger|
+          next(nil) if logger == self
+          logger.is_a?(Class) ? logger.new : logger
+        end
+        @loggers.uniq!
+        @loggers.compact!
+      end
+
+      # integration to Logging
+
+      def log(tag, *args)
+        return if @ignored_tags.include?(tag)
+        @loggers.each do |logger|
+          logger.log(tag, *args)
+        end
+      end
+    end
+
+  end
+end

data/lib/ramaze/log/informer.rb

@@ -0,0 +1,128 @@
+#          Copyright (c) 2008 Michael Fellinger m.fellinger@gmail.com
+# All files in this distribution are subject to the terms of the Ruby license.
+
+module Ramaze
+  module Logger
+
+    # A minimal logger for Ramaze, supports files, CLI, colors and some
+    # customization.
+
+    class Informer
+      include Logging
+
+      attr_accessor :out, :colorize, :log_levels
+
+      # Should Ramaze try to use colors?
+      trait :colorize => true
+
+      # parameter for Time.now.strftime
+      trait :timestamp => "%Y-%m-%d %H:%M:%S"
+
+      # This is how the final output is arranged.
+      trait :format => "[%time] %prefix  %text"
+
+      # Which tag should be in what color
+      COLORS = {
+        :dev   => :blue,
+        :debug => :yellow,
+        :info  => :green,
+        :warn  => :red,
+        :error => :red,
+      }
+
+      # Create a new instance of Informer.
+      # You can spcify
+      #
+      # Examples:
+      #   Informer.new                    #=> logs to stdout with all levels being
+      #                                       shown.
+      #   Informer.new($stderr)           #=> same, but to stderr
+      #   Informer.new("foo.log")         #=> same, but logs to the file foo.log
+      #                                       (or creates it if it doesn't exist yet)
+      #   Informer.new($stdout, [:info])  #=> show only #info messages to stdout.
+
+      def initialize(out = $stdout, log_levels = [:debug, :error, :info, :warn])
+        @colorize = false
+
+        @out =
+          case out
+          when STDOUT, :stdout, 'stdout'
+            $stdout
+          when STDERR, :stderr, 'stderr'
+            $stderr
+          when IO
+            out
+          else
+            if out.respond_to?(:puts)
+              out
+            else
+              File.open(out.to_s, 'ab+')
+            end
+          end
+
+        if @out.respond_to?(:tty?) and class_trait[:colorize]
+          @colorize = @out.tty?
+        end
+
+        @log_levels = log_levels
+      end
+
+      # Close the file we log to if it isn't closed already.
+
+      def shutdown
+        if @out.respond_to?(:close)
+          Log.debug("close, #{@out.inspect}")
+          @out.close
+        end
+      end
+
+      # Integration to Logging.
+
+      def log tag, *messages
+        return if closed? || !@log_levels.include?(tag)
+        messages.flatten!
+
+        prefix = tag.to_s.upcase.ljust(5)
+
+        if @colorize
+          color = COLORS[tag] ||= :white
+          prefix.replace prefix.send(color)
+        end
+
+        messages.each do |message|
+          @out.puts(log_interpolate(prefix, message))
+        end
+
+        @out.flush if @out.respond_to?(:flush)
+      end
+
+      # Takes the prefix (tag), text and timestamp and applies it to
+      # the :format trait.
+
+      def log_interpolate prefix, text, time = timestamp
+        message = class_trait[:format].dup
+
+        vars = { '%time' => time, '%prefix' => prefix, '%text' => text }
+        vars.each{|from, to| message.gsub!(from, to) }
+
+        message
+      end
+
+      # This uses Global.inform_timestamp or a date in the format of
+      #   %Y-%m-%d %H:%M:%S
+      #   # => "2007-01-19 21:09:32"
+
+      def timestamp
+        mask = class_trait[:timestamp]
+        Time.now.strftime(mask || "%Y-%m-%d %H:%M:%S")
+      end
+
+      # is @out closed?
+
+      def closed?
+        @out.respond_to?(:closed?) and @out.closed?
+      end
+    end
+
+  end
+end

data/lib/ramaze/log/knotify.rb

@@ -0,0 +1,28 @@
+#          Copyright (c) 2008 Michael Fellinger m.fellinger@gmail.com
+# All files in this distribution are subject to the terms of the Ruby license.
+
+module Ramaze
+  module Logger
+
+    # Informer for the Knotify notfication system used on KDE.
+    # Doesn't need any special libraries.
+
+    class Knotify
+      include Logging
+
+      trait :present => 16
+
+      # Please see for more information on the API used here:
+      # http://lukeplant.me.uk/articles.php?id=3
+
+      def log(tag, *messages)
+        present = class_trait[:present]
+        tag = tag.to_s.capitalize
+        messages.flatten.each do |message|
+          system(%{dcop knotify default notify Ramaze "#{tag}" "#{message}" '' '' #{present} 0})
+        end
+      end
+    end
+
+  end
+end

data/lib/ramaze/log/logger.rb

@@ -0,0 +1,26 @@
+#          Copyright (c) 2008 Michael Fellinger m.fellinger@gmail.com
+# All files in this distribution are subject to the terms of the Ruby license.
+
+require 'logger'
+
+module Ramaze
+  module Logger
+
+    # Informer for the Stdlib Logger
+
+    class Logger < ::Logger
+
+      # integration to Logging
+
+      def log(tag, *args)
+        __send__(tag, args.join("\n"))
+      end
+
+      # Stub for compatibility
+      def dev(*args)
+        debug(*args)
+      end
+    end
+
+  end
+end

data/lib/ramaze/log/logging.rb

@@ -0,0 +1,89 @@
+#          Copyright (c) 2008 Michael Fellinger m.fellinger@gmail.com
+# All files in this distribution are subject to the terms of the Ruby license.
+
+module Ramaze
+
+  # This module provides a basic skeleton for your own loggers to be compatible.
+  # The minimal usage is like this:
+  #
+  #   class MyLogger
+  #     include Logging
+  #
+  #     def log(tag, *args)
+  #       p tag => args
+  #     end
+  #   end
+
+  module Logging
+
+    # Takes the tag (:warn|:debug|:error|:info) and the name of a method to be
+    # called upon elements of msgs that don't respond to :to_str
+    # Goes on and sends the tag and transformed messages each to the #log method.
+    # If you include this module you have to define #log or it will raise.
+
+    def tag_log(tag, meth, *msgs)
+      msgs.each do |msg|
+        string = (msg.respond_to?(:to_str) ? msg : msg.send(meth))
+        log(tag, string)
+      end
+    end
+
+    # Converts everything given to strings and passes them on with :info
+
+    def info(*objects)
+      tag_log(:info, :to_s, *objects)
+    end
+
+    # Converts everything given to strings and passes them on with :warn
+
+    def warn(*objects)
+      tag_log(:warn, :to_s, *objects)
+    end
+
+    # inspects objects if they are no strings. Tag is :debug
+
+    def debug(*objects)
+      tag_log(:debug, :inspect, *objects)
+    end
+
+    # inspects objects if they are no strings. Tag is :dev
+
+    def dev(*objects)
+      tag_log(:dev, :inspect, *objects)
+    end
+
+    alias << debug
+
+    # Takes either an Exception or just a String, formats backtraces to be a bit
+    # more readable and passes all of this on to tag_log :error
+
+    def error(ex)
+      if ex.respond_to?(:exception)
+        message = [ex.backtrace].flatten[0..Global.backtrace_size]
+        message.map{|m| m.to_s.gsub(/^#{Regexp.escape(Dir.pwd)}/, '.') }
+        message.unshift(ex.inspect)
+      else
+        message = ex.to_s
+      end
+      tag_log(:error, :to_s, *message)
+    end
+
+    # raises
+
+    def log(*args)
+      raise "#log should be implemented by an instance including this module (#{self})"
+    end
+
+    # nothing
+
+    def shutdown
+    end
+
+    # stub for WEBrick
+
+    def debug?
+      false
+    end
+  end
+
+end

data/lib/ramaze/log/rotatinginformer.rb

@@ -0,0 +1,168 @@
+module Ramaze
+  
+  module Logger
+
+    # A customized logger (based on Informer) that creates multiple log files based on time
+
+    class RotatingInformer
+      
+      include Logging
+
+      attr_accessor :time_format, :log_levels
+      attr_reader :base_dir
+      
+      # parameter for Time.now.strftime
+      trait :timestamp => "%Y-%m-%d %H:%M:%S"
+
+      # This is how the final output is arranged.
+      trait :format => "[%time] %prefix  %text"
+
+      # Create a new instance of RotatingInformer.
+      #
+      # base_dir is the directory where all log files will be stored
+      #
+      # time_format is the time format used to name the log files.
+      # Possible formats are identical to those
+      # accepted by Time.strftime
+      #
+      # log_levelse is an array describing what kind of messages
+      # that the log receives. The array may contain
+      # any or all of the symbols :debug, :error, :info and/or :warn
+      #
+      # Examples:
+      #   RotatingInformer.new('logs')
+      #                                   #=> Creates logs in directory called logs.
+      #                                       The generated filenames will be in the
+      #                                       form YYYY-MM-DD.log
+      #   RotatingInformer.new('logs', '%Y-%m.txt')
+      #                                   #=> Creates logs in directory called logs.
+      #                                       The generated filenames will be in the
+      #                                       form YYYY-MM.txt
+      #   RotatingInformer.new('logs', '%Y-%m.txt', [:error])
+      #                                   #=> Creates logs in directory called logs.
+      #                                       The generated filenames will be in the
+      #                                       form YYYY-MM.txt. Only errors will be
+      #                                       logged to the files.
+
+      def initialize(base_dir, time_format = '%Y-%m-%d.log', log_levels = [:debug, :error, :info, :warn])
+        # Verify and set base directory
+        send :base_dir=, base_dir, true
+        
+        @time_format = time_format
+        @log_levels = log_levels
+        
+        # Keep track of log shutdown (to prevent StackErrors due to recursion)
+        @in_shutdown = false
+      end
+
+      # Set the base directory for log files
+      # 
+      # If this method is called with the raise_exception
+      # parameter set to true the method will raise an exception
+      # if the specified directory does not exist or is unwritable.
+      # 
+      # If raise_exception is set to false, the method will just
+      # silently fail if the specified directory does not exist
+      # or is unwritable
+      
+      def base_dir=(directory, raise_exception = false)
+        # Expand directory path
+        base_dir = File.expand_path(directory)
+        # Verify that directory path exists
+        if File.exist?(base_dir)
+          # Verify that directory path is a directory
+          if File.directory?(base_dir)
+            # Verify that directory path is writable
+            if File.writable?(base_dir)
+              @base_dir = base_dir
+            else
+              raise Exception.new("#{base_dir} is not writable") if raise_exception
+            end
+          else
+            raise Exception.new("#{base_dir} is not a directory") if raise_exception
+          end
+        else
+          raise Exception.new("#{base_dir} does not exist.") if raise_exception
+        end
+      end
+      
+      # Close the file we log to if it isn't closed already.
+
+      def shutdown
+        if @out.respond_to?(:close)
+          unless @in_shutdown
+            @in_shutdown = true
+            Log.debug("close, #{@out.inspect}")
+            @in_shutdown = false
+          end
+          @out.close
+        end
+      end
+
+      # Integration to Logging.
+
+      def log tag, *messages
+
+        return unless @log_levels.include?(tag)
+
+        # Update current log
+        update_current_log       
+
+        messages.flatten!
+
+        prefix = tag.to_s.upcase.ljust(5)
+
+        messages.each do |message|
+          @out.puts(log_interpolate(prefix, message))
+        end
+
+        @out.flush if @out.respond_to?(:flush)
+      end
+
+      # Takes the prefix (tag), text and timestamp and applies it to
+      # the :format trait.
+
+      def log_interpolate prefix, text, time = timestamp
+        message = class_trait[:format].dup
+
+        vars = { '%time' => time, '%prefix' => prefix, '%text' => text }
+        vars.each{|from, to| message.gsub!(from, to) }
+
+        message
+      end
+
+      # This uses Global.inform_timestamp or a date in the format of
+      #   %Y-%m-%d %H:%M:%S
+      #   # => "2007-01-19 21:09:32"
+
+      def timestamp
+        mask = class_trait[:timestamp]
+        Time.now.strftime(mask || "%Y-%m-%d %H:%M:%S")
+      end
+
+      # is @out closed?
+
+      def closed?
+        @out.respond_to?(:closed?) && @out.closed?
+      end
+
+      private
+
+      # Checks whether current filename is still valid.
+      # If not, update the current log to point at the new
+      # filename
+
+      def update_current_log
+        out = File.join(@base_dir, Time.now.strftime(@time_format))
+        if @out.nil? || @out.path != out
+          # Close old log if necessary
+          shutdown unless @out.nil? || closed?
+
+          # Start new log
+          @out = File.open(out, 'ab+')
+        end
+      end
+    end
+
+  end
+end