ramaze 2008.06 → 2008.11

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

data/lib/ramaze/log/syslog.rb

@@ -1,41 +1,51 @@
 #          Copyright (c) 2008 Michael Fellinger m.fellinger@gmail.com
+#          Copyright (c) 2008 rob@rebeltechnologies.nl
 # All files in this distribution are subject to the terms of the Ruby license.
 
 require 'syslog'
 
+# Add aliases for the levelnames used by Ramaze logging
+module Syslog
+    alias dev debug
+    alias warn warning
+    alias error err
+    module_function :dev, :warn, :error 
+end
+
 module Ramaze
-  module Logging
     module Logger
-
-      # Informer for Syslog from rubys standard-library.
-
-      class Syslog
-        include ::Syslog
-
-        # opens syslog
-
-        def initialize
-          open unless ::Syslog.opened?
+        # Logger class for writing to syslog. It is a *very* thin wrapper
+        # around the Syslog library.
+        class Syslog
+		    include Logging
+
+            # Open the syslog library, if it is allready open, we reopen it using the
+            # new argument list.  The argument list is passed on to the Syslog library
+            # so please check that, and man syslog for detailed information.  
+            # There are 3 parameters:
+            #
+            #   ident:  The identification used in the log file, defaults to $0
+            #   options:  defaults to  Syslog::LOG_PID | Syslog::LOG_CONS
+            #   facility: defaults to Syslog::LOG_USER
+            #
+            def initialize( *args )
+	    	    ::Syslog.close if ::Syslog.opened?
+	    	    ::Syslog.open( *args )
+            end
+
+            # just sends all messages received to ::Syslog
+            # We simply return if the log was closed for some reason, this behavior
+            # was copied from Informer.  We do not handle levels here. This will
+            # be done by te syslog daemon based on it's configuration.
+            def log(tag, *messages)
+			    return if !::Syslog.opened?
+              	::Syslog.send(tag, *messages)
+            end
+
+            # Has to call the modules singleton-method.
+            def inspect
+              ::Syslog.inspect
+            end
         end
-
-        # alias for default syslog methods so they match ramaze
-        alias error err
-        alias warn warning
-        alias dev debug
-
-        # just sends all messages received to ::Syslog
-        def inform(tag, *args)
-          self.__send__(tag, *args)
-        end
-
-        public :error, :warn
-
-        # Has to call the modules singleton-method.
-        def inspect
-          ::Syslog.inspect
-        end
-      end
-
     end
-  end
 end

data/lib/ramaze/log/xosd.rb

@@ -6,89 +6,87 @@ require 'xosd'
 require 'thread'
 
 module Ramaze
-  module Logging
-    module Logger
-
-      # Informer for the XOSD notification system for X11.
-      #
-      # You can install the ruby-bindings with:
-      #   gem install xosd.
-
-      class Xosd < ::Xosd
-        attr_accessor :options
-
-        include Logging
-
-        DEFAULT = {
-          :font_size       => 20,
-          :font            => "-*-*-*-*-*-*-%d-*-*-*-*-*-*-*",
-          :align           => 'center',
-          :color           => '#FFFFFF',
-          :lines           => 3,
-          :valign          => 'top',
-          :timeout         => 3,
-          :outline_color   => "#000000",
-          :outline_width   => 1,
-          :vertical_offset => 20,
-          :colors => {
-            :error => "#FF0000",
-            :info => "#00FF00",
-            :warn => "#EAA61E",
-            :debug => "#FFFF00"
-          },
-        }
-
-        # keys to ignore when setting the options to the instance.
-        IGNORE = [:colors, :font_size, :lines]
-
-        # Here new messages are pushed to eventually displaying them.
-        QUEUE = Queue.new
-
-        # Create a new instance, valid options are in DEFAULT.
-        # In the background a new thread will be running that checks the QUEUE
-        # and processes all messages that are being sent to it.
-        # This is done to make output nicer and readable.
-
-        def initialize(options = {})
-          @options = DEFAULT.merge(options)
-
-          super(@options[:lines])
-
-          @options.each do |key, value|
-            next if IGNORE.include?(key)
-            value %= @options[:font_size] if key == :font
-            send("#{key}=", value)
-          end
+  module Logger
+
+    # Informer for the XOSD notification system for X11.
+    #
+    # You can install the ruby-bindings with:
+    #   gem install xosd.
+
+    class Xosd < ::Xosd
+      attr_accessor :options
+
+      include Logging
+
+      DEFAULT = {
+        :font_size       => 20,
+        :font            => "-*-*-*-*-*-*-%d-*-*-*-*-*-*-*",
+        :align           => 'center',
+        :color           => '#FFFFFF',
+        :lines           => 3,
+        :valign          => 'top',
+        :timeout         => 3,
+        :outline_color   => "#000000",
+        :outline_width   => 1,
+        :vertical_offset => 20,
+        :colors => {
+        :error => "#FF0000",
+        :info => "#00FF00",
+        :warn => "#EAA61E",
+        :debug => "#FFFF00"
+        },
+      }
+
+      # keys to ignore when setting the options to the instance.
+      IGNORE = [:colors, :font_size, :lines]
+
+      # Here new messages are pushed to eventually displaying them.
+      QUEUE = Queue.new
+
+      # Create a new instance, valid options are in DEFAULT.
+      # In the background a new thread will be running that checks the QUEUE
+      # and processes all messages that are being sent to it.
+      # This is done to make output nicer and readable.
+
+      def initialize(options = {})
+        @options = DEFAULT.merge(options)
+
+        super(@options[:lines])
+
+        @options.each do |key, value|
+          next if IGNORE.include?(key)
+          value %= @options[:font_size] if key == :font
+          send("#{key}=", value)
+        end
 
-          Thread.new(self) do |xosd|
-            loop do
-              items = []
-              lines = xosd.options[:lines]
-              items << QUEUE.shift until QUEUE.empty? or items.size >= lines
+        Thread.new(self) do |xosd|
+          loop do
+            items = []
+            lines = xosd.options[:lines]
+            items << QUEUE.shift until QUEUE.empty? or items.size >= lines
 
-              unless items.empty?
-                # pad up with empty lines to avoid dragging around old messages.
-                items << [:info, ' '] until items.size >= lines
+            unless items.empty?
+              # pad up with empty lines to avoid dragging around old messages.
+              items << [:info, ' '] until items.size >= lines
 
-                items.each_with_index do |(tag, message), i|
-                  xosd.color = xosd.options[:colors][tag.to_sym]
-                  xosd.display(message, i)
-                end
+              items.each_with_index do |(tag, message), i|
+              xosd.color = xosd.options[:colors][tag.to_sym]
+              xosd.display(message, i)
               end
-              sleep xosd.options[:timeout]
             end
+            sleep xosd.options[:timeout]
           end
         end
+      end
 
-        # pushes all messages it gets on the QUEUE for further processing.
+      # pushes all messages it gets on the QUEUE for further processing.
 
-        def log(tag, *messages)
-          messages.each do |message|
-            QUEUE << [tag, message]
-          end
+      def log(tag, *messages)
+        messages.each do |message|
+          QUEUE << [tag, message]
         end
       end
-
     end
+
   end
 end

data/lib/ramaze/option.rb

@@ -12,7 +12,7 @@ module Ramaze
         "fcgi"                => "Fcgi",
         "thin"                => "Thin",
         "ebb"                 => "Ebb",
-        "cgi"                 => "CGI",
+        "cgi"                 => "Cgi",
         "lsws"                => "LSWS",
         "scgi"                => "SCGI",
         "webrick"             => "WEBrick",
@@ -73,9 +73,9 @@ module Ramaze
       :controllers, Set.new
 
     o "Instruction for daemonize, only works with bin/ramaze for now",
-      :daemonize, 'start', :cli => [:start, :stop]
+      :daemonize, '', :cli => [:start, :stop]
 
-    o "Turn on customized error pages.",
+    o "Turn on customized error pages. Use Rack::ShowException otherwise.",
       :error_page, true, :cli => true
 
     o "Caching actions to the filesystem in Global.public_root",
@@ -103,10 +103,10 @@ module Ramaze
       :mapping, {}
 
     o "Activate middleware",
-      :middleware, false
+      :middleware, true
 
     o "For your own modes to decide on",
-      :mode, :live, :cli => [:live, :dev]
+      :mode, :live, :cli => [:live, :dev, :spec]
 
     o "The place ramaze was started from, useful mostly for debugging",
       :origin, :main
@@ -117,6 +117,9 @@ module Ramaze
     o "Specify directory to serve static files",
       :public_root, "public", :cli => "public"
 
+    o "Prefix for incoming and outgoing links",
+      :prefix, '/'
+
     o "Record all Request objects by assigning a filtering Proc to me.",
       :record, false
 
@@ -141,7 +144,7 @@ module Ramaze
     o "What signal to trap to call Ramaze::shutdown",
       :shutdown_trap, "SIGINT"
 
-    o "Interval in seconds of the background SourceReload",
+    o "Interval in seconds of the Reloader",
       :sourcereload, 3, :cli => 3
 
     o "Test before start if adapters will be able to connect",