1  # Adds the 'around_level' method to Logger.
   2 
   3  class Logger
   4    def self.define_around_helper(level)
   5      module_eval <<-end_eval
   6        def around_#{level}(before_message, after_message, &block)  # def around_debug(before_message, after_message, &block)
   7          self.#{level}(before_message)                             #   self.debug(before_message)
   8          return_value = block.call(self)                           #   return_value = block.call(self)
   9          self.#{level}(after_message)                              #   self.debug(after_message)
  10          return return_value                                       #   return return_value
  11        end                                                         # end
  12      end_eval
  13    end
  14    [:debug, :info, :error, :fatal].each {|level| define_around_helper(level) }
  15  end
  16 
  17 
  18  require 'logger'
  19 
  20  # Extensions to the built in Ruby logger.
  21  #
  22  # If you want to use the default log formatter as defined in the Ruby core, then you
  23  # will need to set the formatter for the logger as in:
  24  #
  25  #   logger.formatter = Formatter.new
  26  #
  27  # You can then specify the datetime format, for example:
  28  #
  29  #   logger.datetime_format = "%Y-%m-%d"
  30  #
  31  # Note: This logger is deprecated in favor of ActiveSupport::BufferedLogger
  32  class Logger
  33    ##
  34    # :singleton-method:
  35    # Set to false to disable the silencer
  36    cattr_accessor :silencer
  37    self.silencer = true
  38 
  39    # Silences the logger for the duration of the block.
  40    def silence(temporary_level = Logger::ERROR)
  41      if silencer
  42        begin
  43          old_logger_level, self.level = level, temporary_level
  44          yield self
  45        ensure
  46          self.level = old_logger_level
  47        end
  48      else
  49        yield self
  50      end
  51    end
  52 
  53    alias :old_datetime_format= :datetime_format=
  54    # Logging date-time format (string passed to +strftime+). Ignored if the formatter
  55    # does not respond to datetime_format=.
  56    def datetime_format=(datetime_format)
  57      formatter.datetime_format = datetime_format if formatter.respond_to?(:datetime_format=)
  58    end
  59 
  60    alias :old_datetime_format :datetime_format
  61    # Get the logging datetime format. Returns nil if the formatter does not support
  62    # datetime formatting.
  63    def datetime_format
  64      formatter.datetime_format if formatter.respond_to?(:datetime_format)
  65    end
  66 
  67    alias :old_formatter :formatter if method_defined?(:formatter)
  68    # Get the current formatter. The default formatter is a SimpleFormatter which only
  69    # displays the log message
  70    def formatter
  71      @formatter ||= SimpleFormatter.new
  72    end
  73 
  74    unless const_defined? :Formatter
  75      class Formatter
  76        Format = "%s, [%s#%d] %5s -- %s: %s\n"
  77 
  78        attr_accessor :datetime_format
  79 
  80        def initialize
  81          @datetime_format = nil
  82        end
  83 
  84        def call(severity, time, progname, msg)
  85          Format % [severity[0..0], format_datetime(time), $$, severity, progname,
  86          msg2str(msg)]
  87        end
  88 
  89        private
  90          def format_datetime(time)
  91            if @datetime_format.nil?
  92              time.strftime("%Y-%m-%dT%H:%M:%S.") << "%06d " % time.usec
  93            else
  94              time.strftime(@datetime_format)
  95            end
  96          end
  97 
  98          def msg2str(msg)
  99            case msg
 100            when ::String
 101              msg
 102            when ::Exception
 103              "#{ msg.message } (#{ msg.class })\n" <<
 104              (msg.backtrace || []).join("\n")
 105            else
 106              msg.inspect
 107            end
 108          end
 109      end
 110    end
 111 
 112    # Simple formatter which only displays the message.
 113    class SimpleFormatter < Logger::Formatter
 114      # This method is invoked when a log event occurs
 115      def call(severity, timestamp, progname, msg)
 116        "#{String === msg ? msg : msg.inspect}\n"
 117      end
 118    end
 119 
 120    private
 121      alias old_format_message format_message
 122 
 123      # Ruby 1.8.3 transposed the msg and progname arguments to format_message.
 124      # We can't test RUBY_VERSION because some distributions don't keep Ruby
 125      # and its standard library in sync, leading to installations of Ruby 1.8.2
 126      # with Logger from 1.8.3 and vice versa.
 127      if method_defined?(:formatter=)
 128        def format_message(severity, timestamp, progname, msg)
 129          formatter.call(severity, timestamp, progname, msg)
 130        end
 131      else
 132        def format_message(severity, timestamp, msg, progname)
 133          formatter.call(severity, timestamp, progname, msg)
 134        end
 135 
 136        attr_writer :formatter
 137        public :formatter=
 138 
 139        alias old_format_datetime format_datetime
 140        def format_datetime(datetime) datetime end
 141 
 142        alias old_msg2str msg2str
 143        def msg2str(msg) msg end
 144      end
 145  end