log4rails 1.1.11

data/lib/log4r/formatter/formatter.rb

@@ -0,0 +1,105 @@
+# :include: ../rdoc/formatter
+#
+# Version:: $Id$
+
+require "singleton"
+
+require "log4r/base"
+
+module Log4r
+
+  # Formatter is an abstract class and a null object
+  class Formatter
+    def initialize(hash={})
+    end
+    # Define this method in a subclass to format data.
+    def format(logevent)
+    end
+  end
+
+  # SimpleFormatter produces output like this:
+  # 
+  #   WARN loggername> Danger, Will Robinson, danger!
+  #
+  # Does not write traces and does not inspect objects.
+  
+  class SimpleFormatter < Formatter
+    def format(event)
+      sprintf("%*s %s> %s\n", MaxLevelLength, LNAMES[event.level], 
+              event.name, event.data)
+    end
+  end
+
+  # BasicFormatter produces output like this:
+  # 
+  #   WARN loggername: I dropped my Wookie!
+  #   
+  # Or like this if trace is on:
+  # 
+  #   WARN loggername(file.rb at 12): Hot potato!
+  #   
+  # Also, it will pretty-print any Exception it gets and
+  # +inspect+ everything else.
+  #
+  # Hash arguments include:
+  #
+  # +depth+::  How many lines of the stacktrace to display.
+
+  class BasicFormatter < SimpleFormatter
+    @@basicformat = "%*s %s"
+
+    def initialize(hash={})
+      @depth = (hash[:depth] or hash['depth'] or 7).to_i
+    end
+    
+    def format(event)
+      buff = sprintf(@@basicformat, MaxLevelLength, LNAMES[event.level],
+             event.name)
+      buff << (event.tracer.nil? ? "" : "(#{event.tracer[0]})") + ": "
+      buff << format_object(event.data) + "\n"
+      buff
+    end
+
+    # Formats data according to its class:
+    #
+    # String::     Prints it out as normal.
+    # Exception::  Produces output similar to command-line exceptions.
+    # Object::     Prints the type of object, then the output of
+    #              +inspect+. An example -- Array: [1, 2, 3]
+
+    def format_object(obj)
+      if obj.kind_of? Exception
+        return "Caught #{obj.class}: #{obj.message}\n\t" +
+               (obj.backtrace.nil? ? [] : obj.backtrace[0...@depth]).join("\n\t")
+      elsif obj.kind_of? String
+        return obj
+      else # inspect the object
+        return "#{obj.class}: #{obj.inspect}"
+      end
+    end
+  end
+
+  # Formats objects the same way irb does:
+  #
+  #   loggername:foo.rb in 12> 
+  #   [1, 3, 4]
+  #   loggername:foo.rb in 13> 
+  #   {1=>"1"}
+  #
+  # Strings don't get inspected. just printed. The trace is optional.
+
+  class ObjectFormatter < Formatter
+    def format(event)
+      buff = event.logger.name
+      buff << (event.tracer.nil? ? "" : ":#{event.tracer[0]}") + ">\n"
+      buff << (event.data.kind_of?(String) ? event.data : event.data.inspect)
+      buff << "\n"
+    end
+  end
+  
+  # Outputters that don't define a Formatter will get this, which
+  # is currently BasicFormatter
+  class DefaultFormatter < BasicFormatter
+  end
+  
+end

data/lib/log4r/formatter/log4jxmlformatter.rb

@@ -0,0 +1,65 @@
+# :include: ../rdoc/log4jxmlformatter
+#
+# == Other Info
+#
+# Version:: $Id$
+
+require "log4r/formatter/formatter"
+
+require "rubygems"
+begin
+  require "builder"
+rescue LoadError
+  puts "builder gem is required to use log4jxmlformatter, i.e. gem install builder"
+end
+
+module Log4r
+
+  class Log4jXmlFormatter < BasicFormatter
+    
+    def format(logevent)
+      logger = logevent.fullname.gsub('::', '.')
+      timestamp = (Time.now.to_f * 1000).to_i
+      level = LNAMES[logevent.level]
+      message = format_object(logevent.data)
+      exception = message if logevent.data.kind_of? Exception
+      file, line, method = parse_caller(logevent.tracer[0]) if logevent.tracer
+      
+      builder = Builder::XmlMarkup.new
+      xml = builder.log4j :event, :logger => logger,
+                                  :timestamp => timestamp,
+                                  :level => level,
+                                  :thread => '' do |e|
+              e.log4j :NDC, NDC.get
+              e.log4j :message, message
+              e.log4j :throwable, exception if exception
+              e.log4j :locationInfo, :class => '',
+                                     :method => method,
+                                     :file => file,
+                                     :line => line
+              e.log4j :properties do |p|
+                MDC.get_context.each do |key, value|
+                  p.log4j :data, :name => key, :value => value
+                end
+              end
+            end
+      xml
+    end
+
+    #######
+    private
+    #######
+
+    def parse_caller(line)
+      if /^(.+?):(\d+)(?::in `(.*)')?/ =~ line
+        file = Regexp.last_match[1]
+        line = Regexp.last_match[2].to_i
+        method = Regexp.last_match[3]
+        [file, line, method]
+      else
+        []
+      end
+    end
+  end
+
+end

data/lib/log4r/formatter/patternformatter.rb

@@ -0,0 +1,145 @@
+# :include: ../rdoc/patternformatter
+#
+# == Other Info
+#
+# Version:: $Id$
+
+require "log4r/formatter/formatter"
+require "log4r/GDC"
+require "log4r/MDC"
+require "log4r/NDC"
+  
+module Log4r
+  # See log4r/formatter/patternformatter.rb
+  class PatternFormatter < BasicFormatter
+  
+    # Arguments to sprintf keyed to directive letters<br>
+    # %c - event short name<br>
+    # %C - event fullname<br>
+    # %d - date<br>
+    # %g - Global Diagnostic Context (GDC)<br>
+    # %t - trace<br>
+    # %m - message<br>
+    # %h - thread name<br>
+    # %p - process ID aka PID<br>
+    # %M - formatted message<br>
+    # %l - Level in string form<br>
+    # %x - Nested Diagnostic Context (NDC)<br>
+    # %X - Mapped Diagnostic Context (MDC), syntax is "%X{key}"<br>
+    # %% - Insert a %<br>
+    DirectiveTable = {
+      "c" => 'event.name',
+      "C" => 'event.fullname',
+      "d" => 'format_date',
+      "g" => 'Log4r::GDC.get()',
+      "t" => '(event.tracer.nil? ? "no trace" : event.tracer[0])',
+      "T" => '(event.tracer.nil? ? "no trace" : event.tracer[0].split(File::SEPARATOR)[-1])',
+      "m" => 'event.data',
+      "h" => '(Thread.current[:name] or Thread.current.to_s)',
+      "p" => 'Process.pid.to_s',
+      "M" => 'format_object(event.data)',
+      "l" => 'LNAMES[event.level]',
+      "x" => 'Log4r::NDC.get()',
+      "X" => 'Log4r::MDC.get("DTR_REPLACE")',
+      "%" => '"%"'
+    }
+  
+    # Matches the first directive encountered and the stuff around it.
+    #
+    # * $1 is the stuff before directive or "" if not applicable
+    # * $2 is the directive group or nil if there's none
+    # * $3 is the %#.# match within directive group
+    # * $4 is the .# match which we don't use (it's there to match properly)
+    # * $5 is the directive letter
+    # * $6 is the stuff after the directive or "" if not applicable
+    # * $7 is the remainder
+  
+    DirectiveRegexp = /([^%]*)((%-?\d*(\.\d+)?)([cCdgtTmhpMlxX%]))?(\{.+?\})?(.*)/
+  
+    # default date format
+    ISO8601 = "%Y-%m-%d %H:%M:%S"
+    
+    attr_reader :pattern, :date_pattern, :date_method
+  
+    # Accepts the following hash arguments (either a string or a symbol):
+    #
+    # [<tt>pattern</tt>]         A pattern format string.
+    # [<tt>date_pattern</tt>]    A Time#strftime format string. See the
+    #                            Ruby Time class for details.
+    # [+date_method+]     
+    #   As an option to date_pattern, specify which
+    #   Time.now method to call. For 
+    #   example, +usec+ or +to_s+.
+    #   Specify it as a String or Symbol.
+    #
+    # The default date format is ISO8601, which looks like this:
+    # 
+    #   yyyy-mm-dd hh:mm:ss    =>    2001-01-12 13:15:50
+  
+    def initialize(hash={})
+      super(hash)
+      @pattern = (hash['pattern'] or hash[:pattern] or nil)
+      @date_pattern = (hash['date_pattern'] or hash[:date_pattern] or nil)
+      @date_method = (hash['date_method'] or hash[:date_method] or nil)
+      @date_pattern = ISO8601 if @date_pattern.nil? and @date_method.nil?
+      PatternFormatter.create_format_methods(self)
+    end
+
+    # PatternFormatter works by dynamically defining a <tt>format</tt> method
+    # based on the supplied pattern format. This method contains a call to 
+    # Kernel#sptrintf with arguments containing the data requested in
+    # the pattern format.
+    #
+    # How is this magic accomplished? First, we visit each directive
+    # and change the %#.# component to  %#.#s. The directive letter is then 
+    # used to cull an appropriate entry from the DirectiveTable for the
+    # sprintf argument list. After assembling the method definition, we
+    # run module_eval on it, and voila.
+    
+    def PatternFormatter.create_format_methods(pf) #:nodoc:
+      # first, define the format_date method
+      if pf.date_method
+        module_eval "def pf.format_date; Time.now.#{pf.date_method}; end"
+      else
+        module_eval <<-EOS
+          def pf.format_date
+            Time.now.strftime "#{pf.date_pattern}"
+          end
+        EOS
+      end
+      # and now the main format method
+      ebuff = "def pf.format(event)\n sprintf(\""
+      _pattern = pf.pattern.dup
+      args = [] # the args to sprintf which we'll append to ebuff lastly
+      while true # work on each match in turn
+        match = DirectiveRegexp.match _pattern
+        ebuff << match[1] unless match[1].empty?
+        break if match[2].nil?
+        # deal with the directive by inserting a %#.#s where %#.# is copied
+        # directy from the match
+        ebuff << match[3] + "s"
+
+	if ( match[5] == 'X' && match[6] != nil ) then
+
+	  # MDC matches, need to be able to handle String, Symbol or Number
+	  match6sub = /[\{\}\"]/
+	  mdcmatches = match[6].match(/\{(:?)(\d*)(.*)\}/)
+
+	  if ( mdcmatches[1] == "" && mdcmatches[2] == "" )
+	    match6sub = /[\{\}]/ # don't remove surrounding "'s if String
+	  end
+	  
+	  args <<
+	    DirectiveTable[match[5]].gsub("DTR_REPLACE", match[6]).gsub(match6sub,'')
+	else
+	  args << DirectiveTable[match[5]]  # cull the data for our argument list
+	end
+        break if match[7].empty?
+        _pattern = match[7]
+      end
+      ebuff << '\n", ' + args.join(', ') + ")\n"
+      ebuff << "end\n"
+      module_eval ebuff
+    end
+  end
+end

data/lib/log4r/lib/drbloader.rb

@@ -0,0 +1,52 @@
+#:nodoc:
+module Log4r
+  begin 
+    require 'romp'
+    HAVE_ROMP = true
+  rescue LoadError
+    HAVE_ROMP = false
+  end
+  
+  if HAVE_ROMP
+
+    module ROMPServer #:nodoc:
+      private
+      def start_server(_uri, accept)
+        @server = ROMP::Server.new(_uri, accept) # what if accept is nil?
+        @server.bind(self, "Log4r::LogServer")
+      end
+    end
+
+    module ROMPClient #:nodoc:
+      private
+      def connect
+        begin
+          @client = ROMP::Client.new(@uri, false)
+          @remote_logger = @client.resolve("Log4r::LogServer")
+        rescue Exception => e
+          Logger.log_internal(-2) {
+            "RemoteOutputter '#{@name}' failed to connect to #{@uri}!"
+          }
+          Logger.log_internal {e}
+          self.level = OFF
+        end
+      end
+      # we use propagated = true
+      def send_buffer
+        begin
+          @buff.each {|levent| 
+            lname = LNAMES[levent.level].downcase
+            @remote_logger.oneway(lname, levent, true)
+          }
+        rescue Exception => e
+          Logger.log_internal(-2) {"RemoteOutputter '#{@name}' can't log!"}
+          Logger.log_internal {e}
+          self.level = OFF
+        ensure @buff.clear
+        end
+      end
+    end
+
+  end
+
+end

data/lib/log4r/lib/xmlloader.rb

@@ -0,0 +1,24 @@
+#:nodoc:
+module Log4r
+  begin
+    require 'rexml/document'
+    HAVE_REXML = true
+  rescue LoadError
+    HAVE_REXML = false
+  end
+end
+
+if Log4r::HAVE_REXML
+  module REXML #:nodoc: all
+    class Element
+      def value_of(elmt)
+        val = attributes[elmt]
+        if val.nil?
+          sub = elements[elmt]
+          val = sub.text unless sub.nil?
+        end
+        val
+      end
+    end
+  end
+end

data/lib/log4r/log4r-rails.yaml

@@ -0,0 +1,60 @@
+# default log4r configuration for rails.
+log4r_config:
+  loggers:
+    - name          : 'rails'
+      level         : DEBUG
+      additive      : false
+      trace         : false
+      outputters    : 
+      - console
+
+    - name          : 'rails::db'
+      level         : DEBUG
+      additive      : false
+      trace         : false
+      outputters    : 
+      - console
+      
+    - name          : 'rails::controllers'
+      level         : DEBUG
+      additive      : false
+      trace         : false
+      outputters    : 
+      - console
+      
+    - name          : 'rails::params'
+      level         : INFO
+      additive      : false
+      trace         : false
+      outputters    : 
+      - console
+
+    - name          : 'rails::models'
+      level         : DEBUG
+      additive      : false
+      trace         : false
+      outputters    : 
+      - console
+
+    - name          : 'rails::cache'
+      level         : DEBUG
+      additive      : false
+      trace         : false
+      outputters    : 
+      - console
+
+    - name          : 'rails::mailers'
+      level         : DEBUG
+      additive      : false
+      trace         : false
+      outputters    : 
+      - console
+
+  # define all outputters (incl. formatters)
+  outputters:
+  - type: StdoutOutputter
+    name: console
+    formatter:
+      date_pattern: '%H:%M:%S'
+      pattern     : '%d %l: %m'
+      type        : PatternFormatter